Qu'est-ce que Gradle dans Android Studio?

Gradle est un peu déroutant pour moi, et aussi pour tout nouveau développeur Android. Quelqu'un peut-il expliquer ce qu'est Gradle dans Android Studio et quel est son but? Pourquoi est-il inclus dans Android Studio?

Réponse courte

Gradle est un système de construction.

Longue réponse

Avant Android Studio, vous utilisiez Eclipse à des fins de développement et vous ne saviez probablement pas comment créer votre APK Android sans Eclipse.

Vous pouvez le faire sur la ligne de commande, mais vous devez apprendre ce que fait chaque outil (dx, aapt) dans le SDK. Eclipse nous a tous sauvés de ces détails bas mais importants et fondamentaux en nous donnant leur propre système de construction.

Maintenant, vous êtes-vous déjà demandé pourquoi le resdossier se trouve dans le même répertoire que votre srcdossier?

C'est là que le système de construction entre en scène. Le système de construction prend automatiquement tous les fichiers source ( .javaou .xml), puis applique l'outil approprié (par exemple, prend javales fichiers de classe et les convertit en dexfichiers), et les regroupe tous dans un fichier compressé, notre APK bien-aimé.

Ce système de build utilise certaines conventions: un exemple est de spécifier le répertoire contenant les fichiers source (dans Eclipse c'est le \srcdossier) ou les fichiers de ressources (dans Eclipse c'est le \resdossier).

Maintenant, pour automatiser toutes ces tâches, il doit y avoir un script; vous pouvez écrire votre propre système de construction en utilisant des scripts shell sous linux ou la syntaxe des fichiers batch dans Windows. Je l'ai?

Gradle est un autre système de build qui prend les meilleures fonctionnalités des autres systèmes de build et les combine en un seul. Il est amélioré en fonction de leurs lacunes. Il s'agit d'un système de construction basé sur JVM , ce qui signifie que vous pouvez écrire votre propre script en Java, qu'Android Studio utilise.

Une chose intéressante à propos de gradle est qu'il s'agit d'un système basé sur un plugin . Cela signifie que si vous avez votre propre langage de programmation et que vous souhaitez automatiser la tâche de construction d'un package (sortie comme un JAR pour Java) à partir de sources, vous pouvez écrire un plugin complet en Java ou Groovy (ou Kotlin, voir ici ), et le distribuer au reste du monde.

Pourquoi Google l'a-t-il utilisé?

Google a vu l'un des systèmes de construction les plus avancés du marché et s'est rendu compte que vous pouviez écrire vos propres scripts avec peu ou pas de courbe d'apprentissage, et sans apprendre Groovy ou toute autre nouvelle langue. Ils ont donc écrit le plugin Android pour Gradle.

Vous devez avoir vu des build.gradlefichiers dans votre projet. C'est là que vous pouvez écrire des scripts pour automatiser vos tâches. Le code que vous avez vu dans ces fichiers est du code Groovy. Si vous écrivez, System.out.println("Hello Gradle!");il s'imprimera sur votre console.

Que pouvez-vous faire dans un script de construction?

Un exemple simple est que vous devez copier certains fichiers d'un répertoire à un autre avant que le processus de génération réel ne se produise. Un script de construction Gradle peut le faire.

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

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

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

Gradle est un système de build fonctionnant sur Android Studio .

Dans d'autres langues par exemple:

• Fourmi et Maven de Java
• Rake of Ruby
• AAP de C
• NAnt de .NET
• Faire sous Linux

Voici une explication détaillée de ce qu'est Gradleet 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ération génère automatiquement tous les fichiers de génération Gradle nécessaires.

Fichiers de construction Gradle

2. Les fichiers de construction Gradle utilisent un Domain Specific Language or DSLpour définir une logique de construction personnalisée et pour interagir avec les éléments spécifiques à Android du plug-in Android pour Gradle.

3. Les projets Android Studio se composent d'un ou plusieurs modules, qui sont des composants que vous pouvez créer, tester et déboguer indépendamment. Chaque module a son propre fichier de construction, donc chaque projet Android Studio contient 2 types de fichiers de construction Gradle.

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

5. Fichier de construction au niveau du module : chaque module possède son propre fichier de construction Gradle qui contient les paramètres de construction spécifiques au module. Vous passerez la majeure partie de votre temps à modifier les fichiers de construction de niveau module plutôt que le fichier de construction de niveau supérieur de votre projet.

Pour jeter un œil à ces build.gradlefichiers, 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 du module

Fichier de construction Gradle de niveau supérieur

Chaque projet Android Studio contient un seul fichier de construction Gradle de niveau supérieur. Ce build.gradlefichier 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 de modifier ce fichier, mais il est toujours utile de comprendre son contenu et le rôle qu'il joue dans votre projet.

Fichiers de construction Gradle au niveau du module

En plus du fichier de construction Gradle au niveau du projet, chaque module possède son propre fichier de construction Gradle. Vous trouverez ci-dessous une version annotée d'un fichier de construction Gradle de niveau module.

Autres fichiers Gradle

En plus des fichiers build.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 que jouent ces fichiers dans votre projet.

gradle-wrapper.properties (version Gradle)

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

settings.gradle

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

gradle.properties (Propriétés du projet)

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

local.properties (emplacement du SDK)

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

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

Lecture suggérée - Tutoriel Tutsplus

J'ai compris clairement Gradle de cela.

Gradle est un type d' outil de construction qui construit le code source du programme. C'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.

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

CONFIGURATIONS DE BASE

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

BIBLIOTHÈQUES :: Nous pouvons ajouter des bibliothèques Android ou toute autre bibliothèque tierce en plus selon les exigences faciles, ce qui était une tâche fastidieuse plus tôt. Si la bibliothèque ne convient pas au projet existant, le développeur affiche un journal où 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 DE VARIÉTÉS DE CONSTRUCTIONS

Combiner des types de build avec des saveurs de build pour obtenir des variétés de variantes de build

 ====================                         ====================
|     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 génération générée en supprimant les ressources inutilisées et les éléments inutilisés des bibliothèques intégrées

GÉRER LES AUTORISATIONS

Nous pouvons spécifier certaines autorisations pour certaines versions en ajoutant 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 appareils 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

Tutoriels Vogella

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 les suivants:

• Facilitez la réutilisation du code et des ressources
• Facilitez la création de plusieurs variantes d'une application, soit pour une distribution multi-apk, soit pour différentes versions d'une application
• Facilitez la configuration, l'extension et la personnalisation du processus de construction
• Bonne intégration IDE

Pourquoi Gradle?

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 via des plugins.

Voici quelques-unes de ses fonctionnalités qui nous ont fait choisir Gradle:

• DSL (Domain Specific Language) pour décrire et manipuler la logique de construction
• Les fichiers de construction sont basés sur Groovy et permettent de mélanger des éléments déclaratifs via la DSL et d'utiliser du code pour manipuler les éléments DSL afin de fournir une logique personnalisée.
• Gestion des dépendances intégrée via Maven et / ou Ivy.
• Très souple. Permet d'utiliser les meilleures pratiques mais n'impose 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

Je réfère deux tutoriels pour écrire la réponse un , deux

Gradle est un outil de construction déclaratif à usage général. Il est à 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. C'est déclaratif car 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, il rend également l'outil adaptable et les développeurs ont la possibilité de s'é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 DSL (Domain Specific Language). Il a la puissance et la flexibilité de l'outil Ant avec des fonctionnalités Maven telles que le cycle de vie de la construction et la facilité d'utilisation.

Pourquoi Gradle? Pourquoi maintenant?

La réponse de l'outil de construction consiste à ajouter des fonctionnalités de script via des mécanismes d'extension non standard. Vous finissez par mélanger du code de script avec XML ou par invoquer des scripts externes à partir de votre logique de génération. 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 par la fenêtre.

Supposons que vous souhaitiez copier un fichier vers un emplacement spécifique lorsque vous créez la version finale de votre projet. Pour identifier la version, vous 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, exprimer cette logique simple devient assez difficile.

Evolution des outils de build Java

La logique de construction Java 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 du programme et la logique conditionnelle. Au fur et à mesure que la complexité d'un script de construction augmente, le maintien du code du bâtiment devient un cauchemar.

Dans Ant , vous faites dépendre la cible JAR de la cible de compilation. Ant ne donne aucune indication 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 intégrées au contrôle de version car il n'existe aucun mécanisme automatisé pour les extraire d'un emplacement central.

Maven 1 , libéré en juillet 2004, a tenté de faciliter ce processus. Il a fourni une structure de répertoire et de projet normalisée, ainsi qu'une gestion des dépendances. Malheureusement, la logique personnalisée est difficile à mettre en œuvre

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

Gradle combine les meilleures fonctionnalités des autres outils de construction.

Ensemble de fonctionnalités convaincantes de Gradle

Pourquoi construire vos projets Java avec Gradle plutôt qu'avec Ant ou Maven?

L'outil de build par défaut pour Android (et la nouvelle star des outils de build sur la JVM) est conçu pour faciliter l'écriture de scripts de builds multilingues complexes. Devriez-vous y changer, cependant, si vous utilisez Ant ou Maven?

La clé pour déverrouiller les fonctionnalités 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 ne peut pas connaître toutes les exigences spécifiques à la construction de votre entreprise. En exposant les crochets 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. Lorsque vous traitez un domaine problématique complexe, dans ce cas, la tâche de créer un logiciel, de pouvoir 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 vers des bibliothèques externes, un problème très courant résolu par les outils de construction. Gradle prêt à l'emploi 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 outils de construction

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

Automatiser votre projet de la construction au déploiement

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

• Compiler le code

• Exécution de tests unitaires et d'intégration

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

• Création de la distribution

• Provisionner l'environnement cible

• Déployer le livrable

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

Je réfère deux tutoriels pour écrire la réponse un , deux

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 build se présentent sous différentes formes et sont utilisés pour diverses tâches de build de logiciel. Alors que leur objectif principal est de créer efficacement des exécutables.

L'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, notamment: la compilation du code source informatique en code binaire, l'empaquetage du code binaire et l'exécution de tests automatisés.

Peu de systèmes de construction similaires pour d'autres langues sont (voir la liste complète ici ):

1. Apache Ant et Apache Maven - Java
2. sbt (Simple Build Tool) - pour Scala (Play framework etc)
3. AAP - Outil de construction basé sur Python
4. Râteau (Apache Builder) - Ruby
5. Leiningen pour Clojure

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

Expérience typique de Clojure:

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

Expérience typique d'Android Studio / Gradle:

• "Importer mon projet Eclipse".
• Projet OK importé.
• Gradle fait c'est merci ... attends ... attends ... attends ... Gradle a fini.
• Compiler ... ne peut pas compiler parce que je ne sais pas ce qu'est un X / je ne trouve pas la bibliothèque Y.

Je ne suis pas sûr que ce soit la faute de Gradle exactement. Mais l '"importation depuis le projet Eclipse" semble assez floconneux. Pour toute la sophistication supposée de Gradle et les vertus d'un système de build, Android Studio ne semble tout simplement pas importer très bien les dépendances de build ou le processus de build d'Eclipse.

Il ne vous dit pas quand il n'a pas pu importer un graphique de dépendance complet. L'Android Studio ne fournit aucune aide ou astuce utile pour résoudre le problème. Il ne vous indique pas où vous pouvez rechercher manuellement dans les dossiers Eclipse. Il ne vous dit pas quelle bibliothèque semble manquer. Ou aidez-vous à rechercher Maven, etc. pour eux.

En 2016, des choses comme Leiningen / Clojars, ou npm de nœud, ou pip de Python, ou l'apkg Debian (et je suis sûr que de nombreux gestionnaires de paquets similaires pour d'autres langages et systèmes) fonctionnent tous à merveille ... les dépendances manquantes appartiennent au passé.

Sauf avec Android. Android Studio est désormais le seul endroit où il me semble que je ressens encore un enfer de 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 / tutoriels en ligne existants) lorsqu'ils ont décidé cavalièrement de passer d'Eclipse à Android Studio / Gradle sans produire de processus de conversion robuste. Les personnes dont les projets fonctionnent dans Eclipse ne les adaptent pas à AS (probablement parce que c'est pénible pour eux). Et les gens qui essaient d'utiliser ces projets dans AS rencontrent les mêmes problèmes.

Et de toute façon, si Gradle est ce système de construction super puissant, pourquoi suis-je toujours en train de gérer beaucoup d'autres dépendances dans le gestionnaire sdk? Pourquoi un projet qui n'a pas besoin, par exemple, du NDK le spécifie dans son fichier Gradle afin qu'il soit automatiquement installé et construit en cas de besoin? Pourquoi NDK est-il spécial? De même pour les plateformes cibles? Pourquoi est-ce que je les installe explicitement dans l'IDE plutôt que de simplement vérifier mon projet par rapport à eux et d'avoir tout 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 via des plugins!

Avantages:

• Dsl - Langage spécifique au domaine, basé sur groovy
• DAG - Graphique acyclique dirigé
• 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 l'entrée et de la sortie de sa tâche.
• Si l'instantané a changé ou n'existe pas, Gralde réexécutera cette tâche.

Entrées du manifeste

Grâce à la DSL, il est possible de configurer les entrées de manifeste suivantes:

Construire une variante

Par défaut, le plugin Android configure automatiquement le projet pour créer à la fois un débogage et une version finale de l'application.

Dépendances

1. Dépendances locales:

Si vous avez des archives binaires dans votre système de fichiers local dont dépend un module, telles que des fichiers JAR, vous pouvez déclarer ces dépendances dans le fichier de construction de ce module.

2. Dépendances à distance:

Le référentiel doit d'abord être ajouté à la liste, puis la dépendance doit être déclarée de manière à ce que Maven ou Ivy déclarent leurs artefacts.

Gradle est au langage Groovy JVM 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 une langue de domaine spécifique.

Je ne connais pas l'intégration spécifique d'IntelliJ, mais imaginez que vous pouvez "étendre" Groovy de telle sorte que vous puissiez écrire des primitives de langage "build" spécifiques et qu'elles viennent de faire partie du langage Groovy. (La métaprogrammation de Groovy est une discussion en soi.) IntelliJ / Google pourrait utiliser Gradle pour créer un langage de construction de très haut niveau, mais c'est un langage basé sur un standard ouvert et 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 fonctionnalités sont comme

• Personnalisez, configurez et étendez le processus de génération.

• Créez plusieurs fichiers APK pour votre application avec différentes fonctionnalités en utilisant le même projet.

• Réutilisez le code et les ressources.

référer

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 de studio Android.

• Déclaration de dépendance. Vous pouvez déclarer des fichiers jar de dépendance ou des fichiers de bibliothèque hébergés sur un serveur local ou distant.

• 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 keyPasswordet keyAlias, à votre fichier de génération Gradle, vous pouvez utiliser Gradle pour générer des fichiers APK signés.

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

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

Le 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 à l'aide d'ADB (Android Debug Bridge) où il est exécuté.

Gradle est un outil de construction personnalisé et utilisé pour créer un APK ou un kit de package d'application.

par @Brian Gardner:

Gradle est un outil de construction complet 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, notamment Java, Android et Scala.

Caractéristique de Gradle:

1. Gestion des dépendances
2. Utilisation de Ant de Gradle
3. Plugins Gradle
4. Plugin Java
5. Plugin Android
6. Constructions multi-projets

Gradle est ce qui permet d'automatiser la construction de projets Android complexes qui impliquent des dizaines de milliers de lignes de code à partir 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 Android, Gradle dans 99% des cas est ce qui empêche la construction de votre projet. C'est un système complexe et impénétrable qui obscurcit efficacement le processus de construction d'Android et le rend essentiellement inaccessible aux développeurs inexpérimentés, c'est-à-dire que pour créer une application Android d'entrée de gamme simple, le débutant sans méfiance pourrait avoir besoin d'étudier et de comprendre de nombreuses choses pour lesquelles il n'a pas négocié. tel que:

• Structure et écosystème Android APK
• Android Studio
• Classpaths et dépendances Java
• Sensationnel
• Scripts de construction Gradle
• De nombreuses autres technologies complexes et intéressantes

Toutes ces choses sont intéressantes et utiles pour les développeurs Android, mais elles sont loin d'être faciles 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 de temps à essayer d'obtenir une application simple à construire et à être constamment contrecarré par Gradle. Le problème est aggravé de façon perverse par la grande quantité 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 nombreuses, pour les débutants, c'est probablement la meilleure façon d'étudier et de comprendre le processus de construction et l'écosystème Android, et cela vous permet de contrôler complètement la façon dont votre application est construite. Cependant, cette approche convient mieux aux chefs de la technologie profondément irrémédiables qu'aux noobs inexpérimentés essayant Android.

Ce qui brille par son absence (veuillez m'informer s'il y a une telle chose) est un IDE léger d'entrée de gamme avec un ensemble de fonctionnalités réduit qui simplifie simultanément le processus de construction sans le masquer (donc pas les netbeans ou l'éclipse), il pourrait éventuellement encore utilisez Gradle (ce qui n'allait pas avec Ant). Cela devrait permettre de générer facilement des fichiers APK conformes à quelques configurations courantes et d'utiliser une structure de projet pouvant évoluer vers un projet Android Studio complet si vous décidez de procéder 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. Emballez AndroidManifest.xml, le dossier res et le code binaire dans un fichier zip spécialement formaté appelé APK

Résultats de la recherche Extrait présenté sur le Web Android | construire. gradle. Gradle est un système de construction (open source) qui est utilisé pour automatiser la construction, les tests, le déploiement, etc. ... Par exemple, la tâche simple de copier certains fichiers d'un répertoire vers un autre peut être effectuée par le script de construction Gradle avant la construction réelle. processus se produit.

Dans Android Studio, Gradle est utilisé pour construire nos projets d'applications Android, jouant ainsi le rôle d'un système de construction. Avant Android Studio, dans Eclipse, nous avions l'habitude de compiler et de construire les applications à l'aide de l'outil de ligne de commande qui a rapidement été repris par des étapes basées sur l'interface graphique pour créer et exécuter des applications Android dans Eclipse à l'aide d'ANT. Chaque outil de développement d'applications Android doit compiler des ressources, du code source java, des bibliothèques externes et les combiner dans un APK final.

Gradle est un système de construction, qui est responsable de la compilation du code, des tests, du déploiement et de la conversion du code en fichiers .dex et donc d'exécuter l'application sur l'appareil.

Comme Android Studio est livré avec le système Gradle préinstallé, il n'est pas nécessaire d'installer des logiciels d'exécution supplémentaires pour construire notre projet. Chaque fois que vous cliquez sur bouton dans Android Studio, une tâche Gradle se déclenche automatiquement et commence à construire le projet et une fois que Gradle a terminé sa tâche, l'application commence à s'exécuter dans AVD ou dans l'appareil connecté.

Un système de construction comme Gradle n'est pas un compilateur, un éditeur de liens, etc., mais il contrôle et supervise le fonctionnement de la compilation, de la liaison des fichiers, de l'exécution des cas de test et finalement de regrouper le code dans un fichier apk pour votre application Android.

Il existe deux fichiers build.gradle pour chaque projet de studio Android, l'un pour l' application et l'autre pour les fichiers de construction au niveau du projet (niveau module) .

Dans le processus de construction, le compilateur prend le code source, les ressources, les fichiers JAR des bibliothèques externes et AndroidManifest.xml (qui contient les métadonnées sur l'application) et les convertit en fichiers .dex (fichiers exécutables Dalvik) , qui inclut le bytecode . Ce bytecode est pris en charge par tous les appareils Android pour exécuter votre application. Ensuite, APK Manager combine les fichiers .dex et toutes les autres ressources en un seul fichier apk. APK Packager signe un débogage ou une version apk utilisant le débogage ou la libération du magasin de clés respectif.

L' apk de débogage est généralement utilisé à des fins de test ou nous pouvons dire qu'il n'est utilisé qu'au stade du développement. Lorsque votre application est complète avec les fonctionnalités souhaitées et que vous êtes prêt à publier votre application pour un usage externe, vous avez besoin d'une version apk signée à l'aide d'un fichier de clés de version.

Permet maintenant de faire la lumière sur les fichiers Gradle.

setting.gradle Le fichier setting.gradle (Gradle setting) est utilisé pour spécifier tous les modules utilisés dans votre application.

build.gradle (niveau projet) Le fichier build.gradle de niveau supérieur (module) est un fichier de génération de niveau projet, qui définit les configurations de construction au niveau du projet. Ce fichier applique les configurations à tous les modules du projet d'application Android.

build.gradle (niveau application) Le fichier build.gradle au niveau application se trouve dans chaque module du projet Android. Ce fichier inclut le nom de votre package en tant qu'ID d'application, nom de version (version apk), code de version, sdk minimum et cible pour un module d'application spécifique. Lorsque vous incluez des bibliothèques externes (pas les fichiers jar), vous devez le mentionner dans le fichier de niveau d'application pour les inclure dans votre projet en tant que dépendances de l'application.

Remarque: Si une certaine application est développée en variantes pour des modules individuels tels que Smartphone, tablette ou TV, des fichiers de notes séparés doivent être créés pour tous. Vous pouvez même démarrer votre système Gradle via l' outil de ligne de commande. Les commandes suivantes sont utilisées pour cela:

./gradlew build - (projet de construction)
./gradlew clean build - (projet de construction scratch complet)
./gradlew clean build - (exécutez le test)
./gradlew wrapper - (pour voir toutes les tâches disponibles)

Gradle = Groovy + Cradle Hans Dockter commentaire du forum

La confusion est un peu inutile quand on aurait pu l'appeler "Build" ou quelque chose dans Android Studio.

Nous aimons nous rendre les choses difficiles dans la communauté du développement.