Qu'est-ce que Gradle dans Android Studio?

C'est le nouvel outil de construction que Google veut utiliser pour Android. Il est utilisé parce qu'il est plus extensible et utile que ant. Il est destiné à améliorer l'expérience des développeurs.

Vous pouvez voir une conférence de Xavier Ducrohet de L'équipe de Développeurs Android sur Google I/O ici.

Il y a aussi une autre discussion sur Android Studio par Xavier et Tor Norbye, aussi pendant Google I / O ici.

Gradle est un système de construction en cours d'exécution sur Android Studio.

Dans d'autres langues, par exemple:

• Ant et Maven de Java
• Râteau de Ruby
• A-A-P de C
• NAnt de . Net
• Faire dans Linux

Voici une explication détaillée de ce que Gradle est et comment l'utiliser dans Android Studio.

Explorer les fichiers Gradle

1. Chaque fois que vous créez un projet dans Android Studio, le système de génère automatiquement tous les fichiers de génération de Gradle nécessaires.

Fichiers De Construction Gradle

1. Les fichiers de construction Gradle utilisent un Domain Specific Language or DSL pour définir logique de construction personnalisée et d'interagir avec le spécifique Android éléments du plugin Android pour Gradle.

2. Android Studio projects se compose de 1 ou plusieurs modules, qui sont composants que vous pouvez construire, tester et déboguer indépendamment. Chacun module a son propre fichier de construction, de sorte que chaque projet Android Studio contient 2 types de fichiers de construction Gradle.

3. Fichier de construction de niveau supérieur: c'est là que vous trouverez les options de configuration communes à tous les modules qui composent votre projet.

4. Fichier De Construction Au Niveau Du Module: Chaque le module a son propre fichier de construction Gradle qui contient des paramètres de construction spécifiques au module. Vous passerez la plupart de votre temps à éditer les fichiers de construction au niveau du module plutôt que le fichier de construction de niveau supérieur de votre projet.

Pour consulter ces fichiers build.gradle, Ouvrez le panneau Projet D'Android Studio (en sélectionnant L'onglet Projet) et développez le dossier Gradle Scripts. Les deux premiers éléments du dossier Gradle Scripts sont les fichiers de génération Gradle au niveau du projet et au niveau du module

Niveau Supérieur Fichier De Construction Gradle

Chaque projet Android Studio contient un seul fichier de génération Gradle de niveau supérieur. Ce fichier build.gradle est le premier élément qui apparaît dans le dossier Gradle Scripts et est clairement marqué projet.

La Plupart du temps, vous n'aurez pas besoin d'apporter des modifications à ce fichier, mais il est toujours utile de comprendre son contenu et le rôle qu'il joue au sein de votre projet.

Fichiers De Construction Gradle Au Niveau Du Module

En plus de la fichier de construction Gradle au niveau du projet, chaque module a son propre fichier de construction Gradle. Vous trouverez ci-dessous une version annotée d'un fichier de génération Gradle de base au niveau du module.

Autres Fichiers Gradle

En plus de la construction.fichiers gradle, votre dossier Gradle Scripts contient d'autres fichiers Gradle. La plupart du temps, vous n'aurez pas à modifier manuellement ces fichiers car ils seront mis à jour automatiquement lorsque vous apporterez des modifications pertinentes à votre projet. Cependant, c'est une bonne idée de comprendre le rôle ces fichiers jouent dans votre projet.

Gradle-wrapper.propriétés (version Gradle)

Ce fichier permet à d'autres personnes de construire votre code, même si Gradle n'est pas installé sur leur machine. Ce fichier vérifie si la version correcte de Gradle est installée et télécharge la version nécessaire si nécessaire.

Les Paramètres.gradle

Ce fichier fait référence à tous les modules qui composent votre projet.

Gradle.propriété (Propriétés Du Projet)

Ce fichier contient des informations de configuration pour l'ensemble de votre projet. Elle est vide par défaut, mais vous pouvez appliquer un large éventail de propriétés à votre projet en ajoutant à ce fichier.

Locaux.propriétés (emplacement du SDK)

Ce fichier indique au plugin Android Gradle où il peut trouver votre installation de SDK Android.

Note: local.properties contient des informations qui sont spécifiques à l'installation locale de le SDK Android. Cela signifie que vous ne devriez pas garder ce fichier sous contrôle de source.

Bibliographie - Tutsplus Tutoriel

J'ai eu une compréhension claire de gradle à partir de cela.

Gradle est un type de outil de construction qui construit le code source du programme. Il est donc une partie importante D'Android Studio, et doit être installé avant de commencer à développer votre application.

Nous n'avons pas à l'installer séparément, car Android Studio le fait pour nous, lorsque nous faisons notre premier projet.

définition:: Gradle peut être décrit comme un mécanisme de construction structuré où il fournit au développeur les outils et la flexibilité nécessaires pour gérer les ressources d'un projet afin de créer des builds qui sont smaller in size, targeting specific requirements pour certains appareils de certaines configurations

CONFIGURATIONS DE BASE

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

les BIBLIOTHÈQUES:: nous pouvons ajouter des bibliothèques android ou d'autres bibliothèques tierces en plus selon les exigences faciles qui était une tâche fastidieuse plus tôt. Si la bibliothèque ne correspond pas au projet existant, le développeur affiche un journal dans lequel la personne peut trouver une solution appropriée pour apporter des modifications au projet afin que la bibliothèque puisse être ajoutée. C'est juste une ligne de dépendance

génération VARIÉTÉS DE CONSTRUCTIONS

Combinaison de types de construction avec des saveurs de construction pour obtenir des variétés de variantes de construction

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

RÉDUIRE LA TAILLE

Gradle aide à réduire la taille de la construction générée en supprimant les ressources inutilisées et les éléments inutilisés des bibliothèques intégrées

GESTION DES AUTORISATIONS

Nous pouvons Spécifier certaines autorisations pour certains, construit par des ajout de certaines autorisations dans certains scénarios en fonction des exigences

CONSTRUIT POUR CERTAINS APPAREILS

Nous pouvons gérer la génération de build pour certains périphériques qui incluent certaines densités et certains niveaux d'api. Cela aide dans les déploiements de produits dans l'app store en fonction des exigences sur plusieurs types d'appareils

BONNE RÉFÉRENCE

Vogella Tutoriels

Vous pouvez trouver tout ce que vous devez savoir sur Gradle ici: Guide De L'Utilisateur Du Plugin Gradle

Objectifs du nouveau système de construction

, Les objectifs du nouveau système de construction sont:

• facilitent la réutilisation du code et des ressources
• Il est facile de créer plusieurs variantes d'une application, soit pour la distribution Multi-apk ou pour différentes saveurs d'une application
• facilite la configuration, l'extension et la personnalisation de la construction processus
• bonne intégration IDE

Pourquoi Gradle?

Gradle est un système de construction avancé ainsi qu'une construction avancée boîte à outils permettant de créer une logique de construction personnalisée via des plugins.

Voici quelques-unes de ses caractéristiques qui nous fait choisir Gradle:

• langage spécifique au domaine (DSL) pour décrire et manipuler la logique de construction
• les fichiers de construction sont basés sur Groovy et permettent le mélange d'éléments déclaratifs via le DSL et l'utilisation code pour manipuler les éléments DSL pour fournir une logique personnalisée.
• Gestion Intégrée des dépendances via Maven et / ou Ivy.
• très flexible. Permet d'utiliser les meilleures pratiques, mais ne force pas sa propre façon de faire les choses.
• les Plugins peuvent exposer leur propre DSL et leur propre API pour les fichiers de construction à utiliser.
• bonne API D'outillage permettant L'intégration IDE

Gradle est un système de construction . les systèmes de construction sont des outils logiciels conçus pour automatiser le processus de compilation de programmes. Les systèmes de construction se présentent sous diverses formes et sont utilisés pour une variété de tâches de construction logicielle. Alors que leur objectif principal est de créer efficacement des exécutables.

Un autre terme connexe est L'automatisation de la construction qui est le processus d'automatisation de la création d'une construction logicielle et des processus associés, y compris: compiler le code source de l'ordinateur en binaire code, empaquetage de code binaire et exécution de tests automatisés.

Peu de système de construction similaire pour d'autres langues sont (Voir la liste complète ici):

1. Apache Ant & Apache Maven-Java
2. sbt (outil de construction Simple) - pour Scala (cadre de jeu, etc.)
3. un outil de construction basé sur Python
4. Râteau (Constructeur Apache) - Ruby
5. Leiningen pour Clojure

Au risque d'être discursif, je pense que derrière cela se pose la question de savoir pourquoi L'expérience Android Studio / Gradle est si mauvaise.

Expérience Clojure typique:

• téléchargez le projet avec les dépendances listées dans project.clj.
• Leiningen obtient les dépendances grâce à Clojars et Maven.
• Le projet compile.

Expérience typique Android Studio / Gradle:

• "importer mon projet Eclipse".
• OK projet importé.
• Gradle fait c'est thang ... attendre ... attendre ... attendre ... Gradle a fini.
• compiler ... Je ne peux pas compiler parce que je ne sais pas ce qu'est un X / Je ne peux pas trouver la bibliothèque Y.

Je ne suis pas sûr que ce soit la faute de Gradle exactement. Mais le "import from Eclipse project" semble assez floconneux. Pour toute la sophistication présumée de Gradle et les vertus d'un système de construction, Android Studio ne semble tout simplement pas importer très bien les dépendances de construction ou le processus de construction D'Eclipse.

Il ne vous dit pas quand il n'a pas réussi à importer un graphique de dépendance complet. Le studio Android ne donne aucune aide utile ou des conseils sur la façon de résoudre le problème. Il ne vous dit pas où vous pouvez regarder manuellement dans les dossiers Eclipse. Il ne vous dit pas quelle bibliothèque semble manquer. Ou vous aider à rechercher Maven etc. pour eux.

En 2016, des choses comme Leiningen / Clojars, ou le npm de node, ou le pip de Python, ou le Debian apkg (et je suis sûr que beaucoup de gestionnaires de paquets similaires pour d'autres langues et systèmes) tous fonctionnent magnifiquement ... les dépendances manquantes appartiennent au passé.

Sauf avec Android. Android Studio est maintenant le seul endroit où je semble encore éprouver l'enfer de la dépendance manquante.

Je suis enclin à dire que C'est la faute de Google. Ils ont brisé L'écosystème Android (et des milliers de projets Android existants / tutoriels en ligne) quand ils ont cavalierly décidé de passer D'Eclipse à Android Studio / Gradle sans produire un processus de conversion robuste. Les personnes dont les projets fonctionnent dans Eclipse ne les adaptent pas à AS (probablement parce que c'est une douleur pour eux). Et les gens qui essaient d'utiliser ces projets sont frapper les mêmes questions.

Et de toute façon, si Gradle est ce système de construction super-puissant, pourquoi est-ce que je gère encore beaucoup d'autres dépendances dans le gestionnaire de sdk? Pourquoi un projet qui a besoin, par exemple, du ndk ne peut-il pas le spécifier dans son fichier Gradle afin qu'il soit automatiquement installé et intégré en cas de besoin? Pourquoi NDK est-il Spécial? De même pour les plates-formes cibles? Pourquoi est-ce que je les installe explicitement dans L'IDE plutôt que de simplement vérifier mon projet contre eux et d'avoir tout cela trié pour moi dans les coulisses?

Gradle est un système de construction avancé ainsi qu'une boîte à outils de construction avancée permettant de créer une logique de construction personnalisée à travers des plugins!

Avantages:

• Dsl-langage spécifique au domaine, basé sur groovy
• graphe acyclique dirigé par DAG
• constructions incrémentielles
• Modèle de domaine Extensible
• Gradle est toujours à jour
• avant l'exécution d'une tâche, Gradle prend un instantané de sa tâche d'entrée et de sortie.
• dans le cas où le l'instantané a changé ou il n'existe pas, Gralde ré - exécuter cette tâche.

Entrées du Manifeste

Via le DSL, il est possible de configurer ce qui suit entrées du Manifeste:

Construire une variante

Par défaut, le plugin Android configure automatiquement le projet construire à la fois une version de débogage et une version de l'application.

Dépendances

1. Dépendances Locales:

Si vous avez archives binaires dans votre système de fichiers local qu'un module dépend de, tels que les fichiers JAR, vous pouvez déclarer ces dépendances dans le fichier de construction pour ce module.

1. Dépendances Distantes:

Abord le référentiel doit être ajouté à la liste, puis sur le la dépendance doit être déclarée d'une manière que Maven ou Ivy déclarent leur artefact.

Un avantage de Gradle que j'ai trouvé est:

Gradle a été conçu pour les builds multi-projets qui peuvent devenir assez volumineux, et prend en charge les builds incrémentiels en déterminant intelligemment quelles parties de l'arbre de construction sont à jour, de sorte que toute tâche dépendante de ces parties n'aura pas besoin d'être ré-exécutée.

Gradle est au langage JVM Groovy ce que ant est à Java. Fondamentalement, C'est L'outil de construction de Groovy. Contrairement à Ant, il est basé sur le langage Groovy complet. Vous pouvez, par exemple, écrire du code de script Groovy dans le script Gradle pour faire quelque chose plutôt que de compter sur un langage de domaine spécifique.

Je ne connais pas L'intégration spécifique D'IntelliJ, mais imaginez que vous puissiez" étendre " Groovy de sorte que vous puissiez écrire des primitives de langage "build" spécifiques et qu'elles font juste partie du Groovy langue. (La métaprogrammation de Groovy est une discussion en soi. IntelliJ / Google pourrait utiliser Gradle pour construire un langage de construction de très haut niveau, mais c'est un langage construit sur un standard ouvert extensible.

Gradle est une boîte à outils de construction avancée pour android qui gère les dépendances et vous permet de définir une logique de construction personnalisée. les caractéristiques sont comme 1. Personnalisez, configurez et étendez le processus de génération. 2. Créez plusieurs APK pour votre application avec différentes fonctionnalités en utilisant le même projet. 3. Réutiliser le code et les ressources. référez-vous à ce lien http://developer.android.com/sdk/installing/studio-build.html

Dans Android Studio, Gradle est un outil de construction personnalisé utilisé pour construire des packages android (fichiers apk) en gérant les dépendances et en fournissant une logique de construction personnalisée.

Fichier APK (package D'Application Android) est un fichier zip spécialement formaté qui contient

• code octet
• Ressources (images, INTERFACE utilisateur, xml, etc)
• fichier Manifeste

Un fichier apk est signé et poussé vers l'appareil en utilisant ADB (Android Debug Bridge) où il est exécuté.

Gradle est une boîte à outils de construction automatisée qui peut s'intégrer dans de nombreux environnements différents, non seulement pour les projets Android.

Voici quelques choses que vous pouvez faire avec gradle.

• Configuration Minimale Requise pour les nouveaux projets, car Gradle a des configurations par défaut pour vos projets android studio.

• Déclaration De Dépendance. Vous pouvez déclarer des fichiers JAR de dépendance ou des fichiers de bibliothèque hébergés en local ou à distance serveur.

• Gradle génère automatiquement un répertoire de test et un APK de test à partir de la source de votre projet.

• Si vous ajoutez toutes les informations nécessaires, telles que keyPassword et keyAlias, pour votre fichier de build Gradle, vous pouvez utiliser Gradle pour générer signé Apk.

• Gradle peut générer plusieurs APK avec différentes configurations de package et de construction à partir d'un seul module.

Je me réfère à deux tutoriel pour écrire la Réponse un,deux

Gradel est un outil de construction déclaratif à usage général. Il est d'usage général car il peut être utilisé pour construire à peu près tout ce que vous souhaitez implémenter dans le script de construction. Il est déclaratif puisque vous ne voulez pas voir beaucoup de code dans le fichier de construction, qui n'est pas lisible et moins maintenable. Ainsi, alors que Gradle fournit l'idée de conventions et une construction simple et déclarative, elle aussi rend l'outil adaptable et les développeurs la capacité d'étendre. Il fournit également un moyen facile de personnaliser le comportement par défaut et différents crochets pour ajouter des fonctionnalités tierces.

Gradle combine les bonnes parties des deux outils et fournit des fonctionnalités supplémentaires et utilise Groovy comme langage spécifique au domaine (DSL). Il a la puissance et la flexibilité de L'outil de fourmi avec des caractéristiques de Maven telles que le cycle de vie de construction et la facilité d'utilisation.

Pourquoi Gradle? Pourquoi Maintenant?

Le la réponse de build tool consiste à ajouter des fonctionnalités de script via des mécanismes d'extension non standard. Vous finissez par mélanger le code de script avec XML ou par invoquer des scripts externes à partir de votre logique de construction. Il est facile d'imaginer que vous devrez ajouter de plus en plus de code personnalisé au fil du temps. En conséquence, vous introduisez inévitablement une complexité accidentelle, et la maintenabilité sort de la fenêtre.

Disons que vous voulez copier un fichier à un emplacement spécifique lorsque vous construisez la version release de votre projet. Pour identifier la version, Vérifiez une chaîne dans les métadonnées décrivant votre projet. S'il correspond à un schéma de numérotation spécifique (par exemple, 1.0-RELEASE), vous copiez le fichier du point A au point B. D'un point de vue extérieur, cela peut sembler une tâche triviale. Si vous devez compter sur XML, le langage de construction de nombreux outils traditionnels, exprimant cette logique simple devient assez difficile.

Evolution des outils de construction Java

Construction Java la logique doit être décrite en XML. XML est idéal pour décrire les données hiérarchiques, mais ne parvient pas à exprimer le flux de programme et la logique conditionnelle. Comme un script de construction se développe en complexité, le maintien du code de construction devient un cauchemar.

Dans Ant , vous faites dépendre la cible JAR de la cible de compilation. Ant ne donne aucune orientation sur la façon de structurer votre projet. Bien qu'il permette une flexibilité maximale, Ant rend chaque script de construction unique et difficile à comprendre. Les bibliothèques externes requises par votre projet sont généralement vérifiées dans le contrôle de version car il n'y a pas de mécanisme automatisé pour les extraire d'un emplacement central.

Maven 1, publié en juillet 2004, a essayé de faciliter ce processus. Il a fourni une structure de projet et de répertoire normalisée, ainsi que la gestion des dépendances. Malheureusement, la logique personnalisée est difficile à implémenter

Gradle s'intègre parfaitement dans cette génération d'outils de construction et répond à de nombreuses exigences de outils de construction modernes (Figure 1). Il fournit un DSL expressif, une approche de convention sur la configuration et une gestion puissante des dépendances. Il fait le bon choix d'abandonner XML et d'introduire le langage dynamique Groovy pour définir votre logique de construction. Sons irrésistible, n'est-ce pas?

Gradle combine les meilleures caractéristiques d'autres outils de construction.

Ensemble de fonctionnalités convaincantes de Gradle

Pourquoi Construire Votre Projets Java avec Gradle plutôt que Ant ou Maven?

L'outil de construction par défaut pour Android (et la nouvelle star des outils de construction sur la JVM) est conçu pour faciliter les scripts de builds complexes et multilingues. Si vous changez à elle, cependant, si vous utilisez Ant ou Maven?

La clé pour déverrouiller les fonctionnalités de puissance de Gradle dans votre script de construction réside dans la découverte et l'application de son modèle de domaine, comme indiqué dans l'image ci-dessous.

Gradle vous ne pouvez pas connaître toutes les exigences spécifiques à votre version d'entreprise. En exposant les hooks dans les phases du cycle de vie, Gradle permet de surveiller et de configurer le comportement d'exécution du script de construction.

Gradle établit un vocabulaire pour son modèle en exposant un DSL implémenté dans Groovy. Lorsqu'il s'agit d'un domaine de problème complexe, dans ce cas, la tâche de construire un logiciel, être capable d'utiliser un langage commun pour exprimer votre logique peut être un outil puissant.

Un autre exemple est la façon dont vous pouvez exprimer des dépendances à des bibliothèques externes, un problème très commun résolu par les outils de construction. Prêt à L'emploi Gradle vous fournit deux blocs de configuration pour votre script de construction qui vous permettent de définir les dépendances et les référentiels à partir desquels vous souhaitez les récupérer. Si les éléments DSL standard ne correspondent pas à vos besoins, vous pouvez même introduire votre propre vocabulaire via le mécanisme D'extension de Gradle.

Intégration avec D'autres Build Outils

Gradle joue bien avec Ant, Maven et Ivy de ses prédécesseurs, comme le montre l'image ci-dessous.

Automatiser votre projet de la génération au déploiement

Dans l'image: étapes d'un pipeline de déploiement.

• La Compilation du code

• Exécution des tests d'unité et d'intégration

• Effectuer une analyse de code statique et générer un test la couverture

• La Création de la distribution

• L'approvisionnement de l'environnement cible

• Déploiement du livrable

• Effectuer des tests de fumée et fonctionnels automatisés

Je me réfère à deux tutoriel pour écrire la Réponse un,deux

Le système de génération Gradle est conçu pour prendre en charge des scénarios complexes dans la création D'applications Android:

Multi-distribution : la même application doit être personnalisée pour plusieurs clients ou entreprises

Multi-apk: Prise en charge de la création de plusieurs apk pour différents types de périphériques tout en réutilisant des parties du code

Gradle est un outil de construction personnalisé et utilisé pour la construction APK ou connu sous le nom application package kit.

Par @Brian Gardner:

Gradle est un outil de construction étendu et un gestionnaire de dépendances pour la programmation de projets. Il a un langage spécifique au domaine basé sur Groovy. Gradle fournit également un support de construction par convention pour de nombreux types de projets, y compris Java, Android et Scala.

Fonction de Gradle:

1. Gestion Des Dépendances
2. en utilisant Ant de Gradle
3. Greffons Gradle
4. Plugin Java
5. Android Greffon
6. Builds Multi-Projets

Gradle est ce qui permet d'automatiser la construction de projets Android complexes impliquant 10s de milliers de lignes de code provenant de plusieurs sources, projets, bibliothèques, etc. Il peut générer conditionnellement plusieurs APK optimisés basés sur une pléthore de spécifications de configuration - si vous êtes intéressé, les autres réponses fournissent plus de détails sur cet aspect de Gradle.

Cependant, si vous êtes nouveau dans le développement D'Android, Gradle dans 99% des cas est ce que arrête votre projet de construction. C'est un système complexe et impénétrable qui obscurcit efficacement le processus de construction Android et le rend essentiellement indisponible pour les développeurs inexpérimentés, c'est-à-dire afin de construire une application Android d'entrée de gamme simple, le débutant sans méfiance pourrait avoir besoin d'étudier et de comprendre beaucoup de choses pour lesquelles ils ne négociaient pas telles que:

• structure et écosystème Android APK
• Android Studio
• Java Classpaths et dépendances
• Groovy
• scripts de construction Gradle
• beaucoup d'autres technologies complexes et intéressantes

Toutes ces choses sont intéressantes et utiles pour les développeurs Android de savoir, mais ils sont loin d'être facile et présentent une formidable barrière à l'entrée. Je soupçonne que ce qui a inspiré le po à poser cette question Est le sentiment de frustration qui frappe inévitablement le développeur néophyte après avoir passé trop longtemps à essayer d'obtenir une application simple à construire et à être continuellement contrecarré par Gradle. Le problème est perversement exacerbé par la quantité écrasante de documentation hautement technique disponible pour toutes ces technologies. Aussi pour une grande quantité de besoins de développement Gradle est exagéré.

Une alternative consiste à écrire un script shell qui construit votre projet en automatisant les outils disponibles dans le SDK android. Les vertus de cette approche sont nombreux, pour commencer c'est probablement la meilleure façon d'étudier et de comprendre le processus de construction et de la Écosystème Android, et il vous permet de contrôler complètement la façon dont votre application est construite. Cependant, cette approche est plus appropriée pour les chefs de technologie profondément irrémédiables que pour les noobs inexpérimentés essayant android.

Ce qui est remarquable par son absence (veuillez m'informer s'il y a une telle chose) est un IDE d'entrée de gamme, léger avec un ensemble de fonctionnalités réduit qui simplifie simultanément le processus de construction tout en ne l'obscurcissant pas (donc pas netbeans ou eclipse) il pourrait éventuellement encore utiliser Gradle (quel était le problème avec Ant). Il devrait faciliter la génération D'APK conformes à quelques configurations courantes et utiliser une structure de projet pouvant évoluer vers un projet Android Studio complet si vous décidez de le prendre de cette façon.

En termes simples, Gradle est un outil fourni par Android Studio afin de mettre en œuvre deux processus importants:

1. construisez nos projets
2. Paquet AndroidManifest.xml, dossier res, et le code binaire dans un fichier zip spécialement formaté appelé APK

Gradle = Groovy + Berceau Hans dockter Forum comment

La confusion est un peu inutile quand elle aurait pu être appelée "Build" ou quelque chose dans Android Studio.

Nous aimons rendre les choses difficiles pour nous-mêmes dans la communauté du développement.