Contenido

• Explorando los archivos de compilación de Gradle
• 1. settings.gradle
• 2. build.gradle (nivel de proyecto)
• 3. build.gradle (nivel de módulo)
• Declarar las dependencias de su proyecto: bibliotecas locales
• Agregar una dependencia de compilación: repositorios remotos
• Conectando a un repositorio remoto
• Declarando una dependencia remota
• Generación de múltiples APK: cómo crear variantes de compilación
• Crear una tarea personalizada de Gradle
• Construyendo su proyecto con el envoltorio Gradle
• ¿Qué otras tareas de Gradle están disponibles?
• Aprovechar al máximo Gradle: agregar complementos
• El Gradle Kotlin DSL
• Terminando

En lugar de Java, XML o Kotlin, estos archivos de compilación de Gradle utilizan el lenguaje específico de dominio (DSL) basado en Groovy. Si no está familiarizado con Groovy, analizaremos línea por línea cada uno de estos archivos de compilación de Gradle, de modo que al final de este artículo se sentirá cómodo leyendo y escribiendo un código Groovy simple.

Gradle tiene como objetivo facilitarle la vida, al proporcionar un conjunto de configuraciones predeterminadas que a menudo puede usar con una configuración manual mínima: cuando esté listo para construir su proyecto, simplemente presione el botón "Ejecutar" de Android Studio y Gradle comenzará el proceso de construcción para ti.

A pesar del enfoque de "convención sobre la configuración" de Gradle, si su configuración predeterminada no satisface sus necesidades, puede personalizar, configurar y ampliar el proceso de compilación, e incluso modificar la configuración de Gradle para realizar tareas muy específicas.

Dado que los scripts de Gradle están contenidos en sus propios archivos, puede modificar el proceso de compilación de su aplicación en cualquier momento, sin tener que tocar el código fuente de su aplicación. En este tutorial, modificaremos el proceso de compilación utilizando sabores, variantes de compilación y una tarea personalizada de Gradle, todo sin siempre tocando nuestro código de aplicación.

Explorando los archivos de compilación de Gradle

Cada vez que crea un proyecto, Android Studio generará la misma colección de archivos de compilación de Gradle. Incluso si importa un proyecto existente en Android Studio, será todavía cree estos mismos archivos de Gradle y agréguelos a su proyecto.

Para comenzar a comprender mejor Gradle y la sintaxis Groovy, echemos un vistazo línea por línea a cada uno de los archivos de compilación Gradle de Android.

1. settings.gradle

El archivo settings.gradle es donde definirá todos los módulos de su aplicación por nombre, utilizando la palabra clave "incluir". Por ejemplo, si tuviera un proyecto que consta de una "aplicación" y un "segundo módulo", entonces su archivo settings.gradle se vería así:

include: app,: secondmodule rootProject.name = MyProject

Dependiendo del tamaño de su proyecto, este archivo puede ser considerablemente más largo.

Durante el proceso de compilación, Gradle examinará el contenido del archivo settings.gradle de su proyecto e identificará todos los módulos que necesita incluir en el proceso de compilación.

2. build.gradle (nivel de proyecto)

El archivo build.gradle de nivel de proyecto se encuentra en el directorio raíz de su proyecto y contiene configuraciones que se aplicarán a todos sus módulos (también llamados "proyectos" por Gradle).

Debe usar este archivo para definir los complementos, repositorios, dependencias y opciones de configuración que se aplican a cada módulo a lo largo de su proyecto de Android. Tenga en cuenta que si define cualquier tarea de Gradle dentro del archivo build.gradle a nivel de proyecto, aún es posible anular o extender estas tareas para módulos individuales, editando sus correspondientes nivel de módulo archivo build.gradle.

Un típico archivo build.gradle a nivel de proyecto se verá así:

buildscript {repositorios {google () jcenter ()} dependencias {classpath com.android.tools.build:gradle:3.5.0-alpha06 // NOTA: No coloque las dependencias de su aplicación aquí; pertenecen // en el módulo individual build.gradle files}} allprojects {repositories {google () jcenter ()}} task clean (type: Delete) {delete rootProject.buildDir}

Este archivo build.gradle a nivel de proyecto se divide en los siguientes bloques:

• Buildscript Contiene la configuración necesaria para realizar la compilación.
• Repositorios Gradle es responsable de localizar las dependencias de su proyecto y ponerlas a disposición en su compilación. Sin embargo, no todas las dependencias provienen del mismo repositorio, por lo que deberá definir todos los repositorios que Gradle debe buscar para recuperar las dependencias de su proyecto.
• Dependencias Esta sección contiene sus dependencias de complementos, que se descargan y almacenan en su caché local. Debieras no define cualquier dependencia de módulo dentro de este bloque.
• Todos los proyectos. Aquí es donde definirá los repositorios que deberían estar disponibles para todos de los módulos de tu proyecto.

3. build.gradle (nivel de módulo)

Este es el archivo build.gradle a nivel de módulo, que está presente en cada módulo a lo largo de su proyecto. Si su proyecto de Android consta de varios módulos, también consistirá en múltiples archivos build.gradle de nivel de módulo.

Cada archivo build.gradle a nivel de módulo contiene el nombre del paquete de su proyecto, el nombre de la versión y el código de la versión, además del SDK mínimo y de destino para este módulo en particular.

Un archivo build.gradle a nivel de módulo también puede tener su propio conjunto único de instrucciones de compilación y dependencias. Por ejemplo, si está creando una aplicación con un componente Wear OS, entonces su proyecto de Android Studio consistirá en un módulo de teléfono inteligente / tableta separado y un módulo Wear, ya que están dirigidos a dispositivos completamente diferentes, estos módulos tienen drásticamente diferentes dependencias!

Un archivo básico de nivel de módulo build.gradle normalmente se verá así:

aplicar el complemento: com.android.application android {compileSdkVersion 28 defaultConfig {applicationId "com.jessicathornsby.speechtotext" minSdkVersion 23 targetSdkVersion 28 versionCode 1 versionName "1.0" testInstrumentationRunner "androidx.test.runner.AndroidUnfrfrfrfr. getDefaultProguardFile (proguard-android-optimizar.txt), proguard-rules.pro}}} dependencias {implementación fileTree (dir: libs, include:) implementación androidx.appcompat: appcompat: 1.0.2 implementación androidx.constraintlayout: restrictintlayout: 1.1. 3 testImplementation junit: junit: 4.12 androidTestImplementation androidx.test.ext: junit: 1.1.0 androidTestImplementation androidx.test.espresso: espresso-core: 3.1.1}

Echemos un vistazo más de cerca a cada una de estas secciones:

• aplicar plugin Esta es una lista de los complementos necesarios para compilar este módulo. El complemento com.android.application es necesario para configurar el proceso de compilación específico de Android, por lo que se agrega automáticamente.
• androide. Aquí es donde debe colocar todas las opciones específicas de la plataforma del módulo.
• compileSdkVersion. Este es el nivel de API con el que se compila este módulo. No puede usar funciones de una API superior a este valor.
• buildToolsVersion. Esto indica la versión del compilador. En Gradle 3.0.0 y superior, buildToolsVersion es opcional; si no especifica un valor de buildToolsVersion, Android Studio utilizará de forma predeterminada la versión más reciente de Build Tools.
• defaultConfig. Contiene opciones que se aplicarán a todas las versiones de compilación de su aplicación, como sus compilaciones de depuración y lanzamiento.
• ID de aplicación. Este es el identificador único de su aplicación.
• minSdkVersion. Este parámetro define el nivel API más bajo que admite este módulo.
• targetSdkVersion. Este es el nivel máximo de API con el que se ha probado su aplicación. Idealmente, debe probar su aplicación utilizando la última API, lo que significa que el valor targetSdkVersion siempre será igual al valor compileSdkVersion.
• versionCode. Este es un valor numérico para la versión de su aplicación.
• versionName. Esta es una cadena fácil de usar, que representa la versión de su aplicación.
• buildTypes. De forma predeterminada, Android admite dos tipos de compilación: depuración y lanzamiento. Puede usar los bloques "depurar" y "liberar" para especificar la configuración específica del tipo de su aplicación.
• dependencias Aquí es donde definirá las bibliotecas de las que depende este módulo.

Declarar las dependencias de su proyecto: bibliotecas locales

Puede hacer que la funcionalidad adicional esté disponible para sus proyectos de Android, agregando una o más dependencias del proyecto. Estas dependencias pueden ser locales o pueden almacenarse en un repositorio remoto.

Para declarar una dependencia en un archivo JAR local, deberá agregar ese JAR al directorio "libs" de su proyecto.

Luego puede modificar el archivo build.gradle a nivel de módulo para declarar una dependencia en este archivo. Por ejemplo, aquí estamos declarando una dependencia en un JAR "mylibrary".

archivos de implementación (libs / mylibrary.jar)

Alternativamente, si su carpeta "libs" contenía varios JAR, entonces podría ser más fácil decir simplemente que su proyecto depende de todos los archivos ubicados dentro de la carpeta "libs", por ejemplo:

implementación fileTree (dir: libs, include:)

Agregar una dependencia de compilación: repositorios remotos

Si una biblioteca se encuentra en un repositorio remoto, deberá completar los siguientes pasos:

• Defina el repositorio donde se encuentra esta dependencia.
• Declarar la dependencia individual.

Conectando a un repositorio remoto

El primer paso es decirle a Gradle qué repositorio (o repositorios) debe verificar para recuperar todas las dependencias de su proyecto. Por ejemplo:

repositorios {google () jcenter ()}}

Aquí, la línea "jcenter ()" asegura que Gradle verificará el repositorio JCenter, que es un repositorio público gratuito alojado en bintray.

Alternativamente, si usted o su organización mantienen un repositorio personal, entonces deben agregar la URL de este repositorio a su declaración de dependencia. Si el repositorio está protegido con contraseña, también deberá proporcionar su información de inicio de sesión, por ejemplo:

repositorios {mavenCentral () maven {// Configure la URL de destino // url "http://repo.mycompany.com/myprivaterepo"} maven {credenciales {nombre de usuario myUsername contraseña myPassword} url "http://repo.mycompany.com / myprivaterepo "}

Si hay una dependencia presente en varios repositorios, Gradle seleccionará la "mejor" versión de esta dependencia, en función de factores como la antigüedad de cada repositorio y la versión estática.

Declarando una dependencia remota

El siguiente paso es declarar la dependencia en su archivo build.gradle a nivel de módulo. Agrega esta información al bloque de "dependencias", utilizando cualquiera de los siguientes:

• Implementación. Esta es una dependencia normal que necesita cada vez que construye su proyecto. Una dependencia de "implementación" estará presente en todos tus construcciones
• Implementación de test. Esta es una dependencia que se requiere para compilar el origen de prueba de su aplicación y ejecutar pruebas basadas en JVM. Cuando marca una dependencia como "Implementación de prueba", Gradle sabrá que no tiene que ejecutar tareas para esta dependencia durante una compilación normal, lo que puede ayudar a reducir el tiempo de compilación.
• Implementación de Androidtest. Esta es una dependencia que se requiere cuando se ejecutan pruebas en un dispositivo, por ejemplo, el marco Espresso es una "implementación de prueba de Android" común.

Definimos una dependencia remota, utilizando una de las palabras clave anteriores, seguida del grupo de dependencia, nombre y atributos de versión, por ejemplo:

dependencias {implementación fileTree (dir: libs, include:) implementación androidx.appcompat: appcompat: 1.0.2 implementación androidx.constraintlayout: restrictintlayout: 1.1.3 testImplementation junit: junit: 4.12 androidTestImplementation androidx.test.ext: junit: 1.1.0 androidTestImplementation androidx.test.espresso: espresso-core: 3.1.1}

Generación de múltiples APK: cómo crear variantes de compilación

A veces, es posible que deba crear varias versiones de su aplicación. Por ejemplo, es posible que desee lanzar una versión gratuita y una versión paga, que incluye algunas características adicionales.

Esta es una tarea de compilación en la que Gradle puede ayudarlo, así que veamos cómo modificaría el proceso de compilación para crear múltiples APK de un solo proyecto:

• Abra su archivo strings.xml y elimine la cadena de nombre de la aplicación original.
• A continuación, defina los nombres de cada sabor de producto que desea crear; en este caso, estoy usando:

Mi aplicación gratuita Mi aplicación paga

• Abra su archivo AndroidManifest.xml y reemplace android: label = ”@ string / app_name” con:

android: label = "$ {appName}"

• Abra su archivo build.gradle a nivel de módulo y agregue lo siguiente al bloque "android":

saborDimensiones "modo" productFlavors {libre {dimensión "modo" applicationIdSuffix ".free" manifestPlaceholders =} pagado {dimensión "modo" applicationIdSuffix ".paid" manifestPlaceholders =}}}

Analicemos lo que está sucediendo aquí:

• SaborDimensiones. El complemento de Android crea variantes de compilación al combinar sabores de diferentes dimensiones. Aquí, estamos creando una dimensión de sabor que consiste en versiones "gratuitas" y "pagas" de nuestra aplicación. Según el código anterior, Gradle generará cuatro variantes de compilación: paidDebug, paidRelease, freeDebug y freeRelease.
• sabores del producto. Esto especifica una lista de sabores y su configuración, que en el código anterior son "pagados" y "gratuitos".
• Gratis / pagado. Estos son los nombres de nuestros dos sabores de productos.
• Dimensión. Necesitamos especificar un valor de parámetro de "dimensión"; en este caso, estoy usando "modo".
• applicationIdSuffix. Dado que queremos crear múltiples versiones de nuestra aplicación, necesitamos darle a cada APK un identificador de aplicación único.
• manifestPlaceholders. Cada proyecto tiene un único archivo de manifiesto que contiene información importante sobre la configuración de su proyecto. Al crear múltiples variantes de compilación, normalmente querrá modificar algunas de estas propiedades de Manifiesto en el momento de la compilación. Puede usar los archivos de compilación de Gradle para especificar entradas de manifiesto únicas para cada variante de compilación, que luego se insertarán en su manifiesto en el momento de la compilación. En el código anterior, estamos modificando el valor de "appName" dependiendo de si Gradle está creando la versión gratuita o de pago de nuestra aplicación.

Crear una tarea personalizada de Gradle

A veces puede que necesite personalizar el proceso de compilación, utilizando Gradle Tareas.

Una tarea es una colección con nombre de acciones que Gradle ejecutará mientras realiza una compilación, por ejemplo, generar un Javadoc. Gradle admite muchas tareas de forma predeterminada, pero también puede crear tareas personalizadas, lo que puede ser útil si tiene en mente un conjunto muy específico de instrucciones de compilación.

En esta sección, crearemos una tarea personalizada de Gradle que iterará a través de todas las variantes de compilación de nuestro proyecto (paidDebug, paidRelease, freeDebug y freeRelease), crearemos un sello de fecha y hora y luego agregaremos esta información a cada APK generado.

Abra su archivo build.gradle a nivel de módulo y agregue lo siguiente:

tarea addDateAndTime () {// Iterar a través de todas las variantes de compilación de salida // android.applicationVariants.all {variant -> // Iterar a través de todos los archivos APK // variant.outputs.all {output -> // Crear una instancia de la fecha y hora actuales, en el formato especificado // def dateAndTime = new Date (). format ("aaaa-MM-dd: HH-mm") // Agregue esta información al nombre de archivo del APK // def fileName = variante. nombre + "_" + dateAndTime + ".apk" output.outputFileName = fileName}}}

A continuación, tenemos que decirle a Gradle cuando Debería ejecutar esta tarea. Durante una compilación, Gradle identifica todo lo que necesita descargar y todas las tareas que debe ejecutar, y las organiza en un Gráfico Acíclico Dirigido (DAG). Gradle ejecutará todas estas tareas, de acuerdo con el orden definido en su DAG.

Para mi aplicación, voy a usar el método "whenReady", que garantiza que nuestra tarea se llamará una vez que se haya llenado el DAG y Gradle esté listo para comenzar a ejecutar sus tareas.

Agregue lo siguiente a su archivo build.gradle a nivel de módulo:

// Ejecute esta tarea // gradle.taskGraph.whenReady {addDateAndTime}

Pongamos nuestra tarea personalizada y nuestro código de variante de compilación para la prueba, al compilar este proyecto utilizando un comando Gradle.

Construyendo su proyecto con el envoltorio Gradle

Emite comandos Gradle utilizando el contenedor Gradle ("gradlew"). Este script es la forma preferida de iniciar una compilación de Gradle, ya que hace que la ejecución de la compilación sea independiente de su versión de Gradle. Esta separación puede ser útil si está colaborando con otras personas que no necesariamente tienen instalada la misma versión de Gradle.

Al emitir sus comandos de envoltura de Gradle, usará "gradlew" para sistemas operativos tipo Unix, incluidos macOS, y "gradlew.bat" para Windows. Tengo una Mac, así que usaré comandos "gradlew".

Puede emitir comandos de Gradle desde Android Studio:

• En la barra de herramientas de Android Studio, seleccione "Ver> Herramientas Windows> Terminal". Esto abre un panel Terminal en la parte inferior de la ventana IDE.
• Ingrese el siguiente comando en la Terminal:

./gradlew build

Android Studio debería verse así:

• Presione la tecla "Enter" en su teclado. Gradle ahora construirá tu proyecto.

Gradle almacena todos los APK generados en el directorio app / build / salidas / apk de su proyecto, así que navegue a este directorio. La carpeta "APK" debe contener varias carpetas y subcarpetas; asegúrese de que Gradle haya generado un APK para cada una de sus variantes de compilación y que se haya agregado la información correcta de fecha y hora a cada archivo.

¿Qué otras tareas de Gradle están disponibles?

Además de cualquier tarea personalizada que pueda crear, Gradle admite una lista de tareas predefinidas listas para usar. Si tiene curiosidad por ver exactamente qué tareas están disponibles, entonces:

• Abra la ventana Terminal de Android Studio, si aún no está abierta (seleccionando "Ver> Herramientas Windows> Terminal" en la barra de herramientas de Android Studio).
• Escriba lo siguiente en la Terminal:

./gradlew -q tareas

• Presione la tecla "Enter" en su teclado.

Esta tarea de "tareas" ahora se ejecutará, y después de unos momentos, la Terminal mostrará una lista de todas las tareas disponibles para este proyecto, completa con una breve descripción de cada tarea.

Aprovechar al máximo Gradle: agregar complementos

Gradle se entrega con una serie de complementos preinstalados, pero puede ampliar aún más Gradle agregando nuevos complementos. Estos complementos hacen que las nuevas tareas estén disponibles para sus proyectos de Android, por ejemplo, el complemento de Java incluye tareas que le permiten compilar el código fuente de Java, ejecutar pruebas unitarias y crear un archivo JAR, como "compileJava", "compileText", "jar" "Javadoc" y "limpio".

Para aplicar un complemento, agregue la declaración "aplicar complemento" a su archivo build.gradle de nivel de módulo, seguido del nombre del complemento. Por ejemplo, aquí estamos aplicando el complemento Java:

aplicar plugin: java

Si tiene curiosidad por ver qué complementos están disponibles, consulte la búsqueda de complementos de Gradle, que proporciona un registro completo de los complementos de Gradle.

El Gradle Kotlin DSL

De forma predeterminada, escribirá sus scripts de compilación de Gradle utilizando Groovy DSL, pero si es uno de los muchos desarrolladores que han adoptado Kotlin para el desarrollo de Android, puede preferir escribir sus scripts de compilación en Kotlin.

A diferencia de Groovy, Kotlin es un lenguaje de programación de tipo estático, por lo que si realiza el cambio, sus archivos de compilación serán compatibles con las funciones de autocompletado y navegación de código fuente de Android Studio. Además, pasar de Groovy a Kotlin significa que usará el mismo lenguaje de programación en su proyecto, lo que puede hacer que el desarrollo sea más sencillo, ¡especialmente si no está demasiado familiarizado con Groovy!

Si desea comenzar a escribir su lógica de compilación en Kotlin, deberá configurar Gradle Kotlin DSL y seguir las instrucciones en la guía de migración.

Terminando

En este artículo, exploramos la herramienta de automatización de compilación y gestión de dependencias de Android Studio. Examinamos cómo Gradle automatiza el proceso de compilación listo para usar, y cómo puede modificar el proceso de compilación editando los archivos de compilación de Gradle de su proyecto, incluida la creación de tareas personalizadas de Gradle y la generación de múltiples variantes de compilación a partir de un solo proyecto.

¿Has extendido Gradle para automatizar otras partes del proceso de compilación de Android? ¡Háganos saber en los comentarios a continuación!