Skip to content

Most visited

Recently visited

navigation

Configurar tu compilación

Video

Nuevo sistema de compilación de Android SDK

El sistema de compilación de Android compila recursos y código fuente de la app y los empaqueta en APK que puedes probar, implementar, firmar y distribuir. Android Studio usa Gradle, un paquete de herramientas de compilación avanzadas, para automatizar y administrar el proceso de compilación, y al mismo tiempo te permite definir configuraciones de compilación personalizadas y flexibles. Cada configuración de compilación puede definir un conjuntos de código y recursos propios, y reutilizar las partes comunes a todas las versiones de tu app. El complemento de Android para Gradle funciona con el paquete de herramientas de compilación para proporcionar procesos y ajustes configurables específicos para la compilación y prueba de aplicaciones de Android.

Gradle y el complemento de Android se ejecutan independientemente de Android Studio. Esto significa que puedes compilar tus apps para Android desde Android Studio, la línea de comandos de tu máquina o en máquinas en las que no esté instalado Android Studio (como servidores de integración continua). Si no usas Android Studio, puedes aprender a compilar y ejecutar tu app desde la línea de comandos. El resultado de la compilación es el mismo si compilas un proyecto desde la línea de comandos, en una máquina remota o usando Android Studio.

Nota: Debido a que Gradle y el complemento de Android se ejecutan independientemente de Android Studio, debes actualizar las herramientas de compilación por separado. Lee las notas de la versión para obtener información sobre cómo actualizar Gradle y el complemento de Android.

La flexibilidad del sistema de compilación de Android te permite realizar configuraciones de compilación personalizadas sin modificar los archivos de origen principales de tu app. Esta sección te ayuda a comprender la manera en que funciona el sistema de compilación de Android y la forma en que te puede ayudar a personalizar y automatizar varias configuraciones de compilación. Si solo deseas obtener más información acerca de cómo implementar tu app, consulta la sección sobre compilación y ejecución desde Android Studio. Para comenzar a crear configuraciones de compilación personalizadas de inmediato usando Android Studio, consulta Configurar variantes de compilación.

Proceso de compilación

En el proceso de compilación se incluyen muchas herramientas y procesos que convierten tu proyecto en un paquete para aplicaciones de Android (APK). El proceso de compilación es muy flexible, por lo cual resulta útil comprender algo de lo que ocurre a nivel profundo.

Figura 1: Proceso de compilación típico de un módulo de app para Android.

El proceso de compilación para un módulo de app para Android, como se muestra en la figura 1, sigue estos pasos generales:

  1. Los compiladores convierten tu código fuente en archivos DEX (ejecutable de Dalvik), los cuales incluyen el código de bytes que se ejecuta en dispositivos Android, y todo lo demás en recursos compilados.
  2. El empaquetador de APK combina los archivos DEX y los recursos compilados en un solo APK. No obstante, antes de que tu app pueda instalarse e implementarse en un dispositivo Android, se debe firmar el APK.
  3. El empaquetador de APK firma tu APK usando el keystore de depuración o lanzamiento:
    1. Si compilas una versión de depuración de tu app (es decir, una app que solo desees usar para pruebas y generación de perfiles), el empaquetador firmará tu app con el keystore de depuración. Android Studio configura automáticamente nuevos proyectos con un keystore de depuración.
    2. Si compilas una versión de lanzamiento de tu app que desees lanzar de manera externa, el empaquetador firmará tu app con el keystore de lanzamiento. Para crear un keystore de lanzamiento, lee la sección sobre firma tu app en Android Studio.
  4. Antes de generar tu APK final, el empaquetador usa la herramienta zipalign para optimizar tu app de modo que use menos memoria cuando se ejecute en un dispositivo.

Al final del proceso de compilación, tendrás un APK de depuración o un APK de lanzamiento de tu app que podrás usar a fin de implementar, probar o lanzar tu app para usuarios externos.

Configuraciones de compilación personalizadas

Gradle y el complemento de Android te ayudan a configurar los siguientes aspectos de tu compilación:

Tipos de compilación
Los tipos de compilación definen determinadas propiedades que Gradle usa al compilar y empaquetar tu app, y generalmente están configurados para diferentes etapas de tu ciclo de vida de desarrollo. Por ejemplo, el tipo de compilación de depuración habilita opciones de depuración y firma el APK con la clave de depuración, mientras el tipo de compilación de lanzamiento puede reducir, ocultar y firmar tu APK con una clave de lanzamiento para la distribución. Debes definir al menos un tipo de compilación para poder compilar tu app; Android Studio crea los tipos de compilación de depuración y lanzamiento de forma predeterminada. Para comenzar a personalizar configuraciones de empaquetado para tu app, obtén información sobre cómo Configurar tipos de compilaciones.
Tipos de productos
Los tipos de productos representan diferentes versiones de tu app que puedes lanzar para los usuarios, como las versiones gratuita y paga de esta. Puedes personalizar tipos de productos para usar código y recursos diferentes, y al mismo tiempo compartir y reutilizar las partes comunes a todas las versiones de tu app. Los tipos de productos son opcionales y debes crearlos manualmente. Para comenzar a crear diferentes versiones de tu app, obtén información sobre cómo Configurar tipos de productos.
Variantes de compilación
Una variante de compilación es un producto vectorial de un tipo de compilación y un tipo de producto, y es la configuración que Gradle usa para compilar tu app. Usando variantes de compilación, puedes compilar la versión de depuración de tus tipos de productos durante el desarrollo, o versiones de lanzamiento firmadas de tus tipos de productos para distribución. Aunque no configuras variantes de compilación directamente, sí configuras los tipos de compilación y los tipos de productos que las forman. La creación de tipos de compilación o tipos de productos adicionales también crea variantes de compilación adicionales. Para obtener información sobre cómo crear y administrar variantes de compilación, lee el resumen Configurar variantes de compilación.
Entradas del manifiesto
Puedes especificar valores para algunas propiedades del archivo de manifiesto en la configuración de la variante de compilación. Estos valores de compilación anulan los valores existentes en el archivo de manifiesto. Esto es útil si deseas generar varios APK para tus módulos y que los archivos de cada APK tengan un nombre de aplicación diferente, una versión de SDK mínima o una versión de SDK de destino. Cuando hay varios manifiestos, Gradle fusiona las configuraciones de estos.
Dependencias
El sistema de compilación administra dependencias del proyecto desde tu sistema de archivos local y desde repositorios remotos. Esto evita que tengas que buscar, descargar y copiar manualmente paquetes ejecutables de tus dependencias en el directorio de tu proyecto. Para obtener más información, consulta la sección Declarar dependencias.
Firma
El sistema de compilación te permite especificar configuraciones de firma en la configuración de la compilación, y puede firmar tus APK automáticamente durante el proceso de compilación. El sistema de compilación firma la versión de depuración con una clave y un certificado predeterminados usando credenciales conocidas para evitar la solicitud de una contraseña durante la compilación. El sistema de compilación no firma la versión de lanzamiento a menos que definas explícitamente una configuración de firma para esta compilación. Si no tienes una clave de lanzamiento, puedes generar una como se describe en Firmar tu app.
ProGuard
El sistema de compilación te permite especificar un archivo de reglas ProGuard diferentes para cada variante de compilación. El sistema de compilación puede ejecutar ProGuard para reducir y ocultar tus clases durante el proceso de compilación.
Divisiones de APK
El sistema de compilación te permite compilar automáticamente diferentes APK que contengan solo el código y los recursos necesarios para una densidad de pantalla o una interfaz binaria de aplicación (ABI) específica. Para obtener más información, consulta Configurar divisiones de APK.

Archivos de configuración de la compilación

Para crear configuraciones de compilación personalizadas debes realizar cambios en uno o más archivos de configuración de la compilación, o en los archivos build.gradle. Estos archivos de texto sin formato usan lenguaje específico de dominio (DSL) para describir y manipular la lógica de compilación usando Groovy, un lenguaje dinámico para la máquina virtual Java (JVM). No necesitas saber usar Groovy para comenzar a configurar tu compilación, ya que el complemento de Android para Gradle contiene la mayoría de los elementos DSL que necesitas. Para obtener más información sobre el DSL del complemento de Android, lee la Documentación de referencia de DSL.

Al comenzar un nuevo proyecto, Android Studio crea automáticamente algunos de esos archivos, como se muestra en la figura 2, y los completa según valores predeterminados confidenciales.

Figura 2: Estructura predeterminada del proyecto de un módulo de app para Android.

Hay algunos archivos de configuración de compilación de Gradle que forman parte de la estructura estándar del proyecto para una app de Android. Para que puedas comenzar a configurar tu compilación, es importante que comprendas el alcance y el objetivo de cada uno de esos archivos, y los elementos de DSL básicos que deben definir.

Archivo de configuración de Gradle

El archivo settings.gradle, ubicado en el directorio raíz del proyecto, indica a Gradle los módulos que debe incluir al compilar tu app. Para la mayoría de los proyectos, el archivo es sencillo y solo incluye lo siguiente:

include ‘:app’

No obstante, los proyectos con varios módulos deben especificar cada módulo que formará parte de la compilación final.

Archivo de configuración de nivel superior

El archivo build.gradle de nivel superior, ubicado en el directorio raíz del proyecto, define configuraciones de compilación que se aplican a todos los módulos de tu proyecto. De forma predeterminada, el archivo de nivel superior usa el bloque buildscript {} para definir los repositorios y las dependencies de Gradle comunes a todos los módulos del proyecto. En el siguiente código de ejemplo se describen las configuraciones predeterminadas y los elementos de DSL que puedes encontrar en el archivo build.gradle de nivel superior antes de crear un proyecto nuevo.

/**
 * The buildscript {} block is where you configure the repositories and
 * dependencies for Gradle itself--meaning, you should not include dependencies
 * for your modules here. For example, this block includes the Android plugin for
 * Gradle as a dependency because it provides the additional instructions Gradle
 * needs to build Android app modules.
 */

buildscript {

    /**
     * The repositories {} block configures the repositories Gradle uses to
     * search or download the dependencies. Gradle pre-configures support for remote
     * repositories such as JCenter, Maven Central, and Ivy. You can also use local
     * repositories or define your own remote repositories. The code below defines
     * JCenter as the repository Gradle should use to look for its dependencies.
     */

    repositories {
        jcenter()
    }

    /**
     * The dependencies {} block configures the dependencies Gradle needs to use
     * to build your project. The following line adds Android Plugin for Gradle
     * version 2.3.3 as a classpath dependency.
     */

    dependencies {
        classpath 'com.android.tools.build:gradle:2.3.3'
    }
}

/**
 * The allprojects {} block is where you configure the repositories and
 * dependencies used by all modules in your project, such as third-party plugins
 * or libraries. Dependencies that are not required by all the modules in the
 * project should be configured in module-level build.gradle files. For new
 * projects, Android Studio configures JCenter as the default repository, but it
 * does not configure any dependencies.
 */

allprojects {
   repositories {
       jcenter()
   }
}

Archivo de compilación de nivel de módulo

El archivo build.gradle de nivel de módulo, ubicado en cada directorio de <project>/<module>/, te permite configurar ajustes de compilación para el módulo específico en el que se encuentra. La configuración de esos ajustes de compilación te permite proporcionar opciones de empaquetado personalizadas, como tipos de compilación y tipos de productos adicionales, y anular las configuraciones en el manifiesto main/ de la app o en el archivo build.gradle de nivel superior.

En este ejemplo de archivo build.gradle del módulo de app para Android se indican algunos de los elementos y ajustes de DSL básicos que debes conocer.

/**
 * The first line in the build configuration applies the Android plugin for
 * Gradle to this build and makes the android {} block available to specify
 * Android-specific build options.
 */

apply plugin: 'com.android.application'

/**
 * The android {} block is where you configure all your Android-specific
 * build options.
 */

android {

  /**
   * compileSdkVersion specifies the Android API level Gradle should use to
   * compile your app. This means your app can use the API features included in
   * this API level and lower.
   *
   * buildToolsVersion specifies the version of the SDK build tools, command-line
   * utilities, and compiler that Gradle should use to build your app. You need to
   * download the build tools using the SDK Manager.
   */

  compileSdkVersion 26
  buildToolsVersion "26.0.1"

  /**
   * The defaultConfig {} block encapsulates default settings and entries for all
   * build variants, and can override some attributes in main/AndroidManifest.xml
   * dynamically from the build system. You can configure product flavors to override
   * these values for different versions of your app.
   */

  defaultConfig {

    /**
     * applicationId uniquely identifies the package for publishing.
     * However, your source code should still reference the package name
     * defined by the package attribute in the main/AndroidManifest.xml file.
     */

    applicationId 'com.example.myapp'

    // Defines the minimum API level required to run the app.
    minSdkVersion 15

    // Specifies the API level used to test the app.
    targetSdkVersion 26

    // Defines the version number of your app.
    versionCode 1

    // Defines a user-friendly version name for your app.
    versionName "1.0"
  }

  /**
   * The buildTypes {} block is where you can configure multiple build types.
   * By default, the build system defines two build types: debug and release. The
   * debug build type is not explicitly shown in the default build configuration,
   * but it includes debugging tools and is signed with the debug key. The release
   * build type applies Proguard settings and is not signed by default.
   */

  buildTypes {

    /**
     * By default, Android Studio configures the release build type to enable code
     * shrinking, using minifyEnabled, and specifies the Proguard settings file.
     */

    release {
        minifyEnabled true // Enables code shrinking for the release build type.
        proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
    }
  }

  /**
   * The productFlavors {} block is where you can configure multiple product
   * flavors. This allows you to create different versions of your app that can
   * override defaultConfig {} with their own settings. Product flavors are
   * optional, and the build system does not create them by default. This example
   * creates a free and paid product flavor. Each product flavor then specifies
   * its own application ID, so that they can exist on the Google Play Store, or
   * an Android device, simultaneously.
   */

  productFlavors {
    free {
      applicationId 'com.example.myapp.free'
    }

    paid {
      applicationId 'com.example.myapp.paid'
    }
  }

  /**
   * The splits {} block is where you can configure different APK builds that
   * each contain only code and resources for a supported screen density or
   * ABI. You'll also need to configure your build so that each APK has a
   * different versionCode.
   */

  splits {
    // Screen density split settings
    density {

      // Enable or disable the density split mechanism
      enable false

      // Exclude these densities from splits
      exclude "ldpi", "tvdpi", "xxxhdpi", "400dpi", "560dpi"
    }
  }
}

/**
 * The dependencies {} block in the module-level build configuration file
 * only specifies dependencies required to build the module itself.
 */

dependencies {
    compile project(":lib")
    compile 'com.android.support:appcompat-v7:26.0.0'
    compile fileTree(dir: 'libs', include: ['*.jar'])
}

Archivos de propiedades de Gradle

Gradle también incluye dos archivos de propiedades, ubicados en el directorio raíz de tu proyecto, que puedes usar para especificar configuraciones para el paquete de herramientas de compilación de Gradle:

gradle.properties
Aquí puedes configurar ajustes Gradle para todo el proyecto, como el tamaño máximo del montón de daemon de Gradle. Para obtener más información, consulta Entorno de compilación.
local.properties
Configura propiedades del entorno local para el sistema de compilación, como la ruta de acceso para la instalación del SDK. Dado que Android Studio genera automáticamente el contenido de este archivo y es específico para el entorno del programador local, no debes modificar este archivo manualmente ni incluirlo en tu sistema de control de versión.

Sincronización del proyecto con archivos de Gradle

Cuando realizas cambios en los archivos de configuración de la compilación de tu proyecto, Android Studio exige que sincronices los archivos de tu proyecto para poder importar tus cambios a la configuración de la compilación y ejecutar algunas comprobaciones para controlar que tu configuración no genere errores de compilación.

Para sincronizar los archivos de tu proyecto, haz clic en Sync Now en la barra de notificaciones que aparece al realizar un cambio, como se muestra en la figura 3, o haz clic en Sync Project en la barra de menú. Si Android Studio detecta errores en tu configuración (por ejemplo, tu código fuente usa funciones de API que solo están disponibles en un nivel de API superior al de tu compileSdkVersion), aparece la ventana Messages y se describe el problema.

Figura 3: Sincronización del proyecto con archivos de configuración de compilación en Android Studio.

Conjuntos de orígenes

Android Studio agrupa de forma lógica código fuente y recursos para cada módulo en conjuntos de orígenes. El conjunto de orígenes main/ del módulo incluye el código y los recursos empleados por todas sus variantes de compilación. Los directorios adicionales del conjunto de orígenes son opcionales, y Android Studio no los crea automáticamente cuando configuras nuevas variantes de compilación. No obstante, crear conjuntos de orígenes (caso similar al de main/) te ayuda a organizar archivos y recursos que Gradle solo debe usar al compilar ciertas versiones de tu app:

src/main/
Este conjunto de orígenes incluye el código y los recursos comunes a todas las variantes de compilación.
src/<buildType>/
Crea este conjunto de orígenes a fin de incluir código y recursos solo para un tipo de compilación específico.
src/<productFlavor>/
Crea este conjunto de orígenes a fin de incluir código y recursos solo para un tipo de producto específico.
src/<productFlavorBuildType>/
Crea este conjunto de orígenes a fin de incluir código y recursos solo para una variante de compilación específica.

Por ejemplo, para generar la versión “fullDebug” de tu app, el sistema de compilación fusiona código, configuraciones y recursos de los siguientes conjuntos de orígenes:

Nota: Cuando creas un archivo o directorio nuevo en Android Studio usando las opciones del menú File > New, puedes crearlos para un conjunto de orígenes específico. Los conjuntos de orígenes entre los que puedes elegir se basan en tus configuraciones de compilación, y Android Studio crea automáticamente los directorios necesarios, en caso de que no existan.

Si diferentes conjuntos de orígenes contienen diferentes versiones del mismo archivo, Gradle usa el siguiente orden de prioridad para decidir el archivo que se usará (los conjuntos de orígenes de la izquierda anulan los archivos y las configuraciones de los conjuntos de archivos de la derecha):

build variant > build type > product flavor > main source set > library dependencies

Esto permite que Gradle use archivos específicos para la variante de compilación que intentas compilar y al mismo tiempo reutilizar las actividades, la lógica de aplicación y los recursos comunes a otras versiones de tu app. Cuando se fusionan varios manifiestos, Gradle usa el mismo orden de prioridad, de modo que cada variante de compilación puede definir diferentes componentes o permisos en el manifiesto final. Para obtener más información acerca de cómo crear conjuntos de orígenes personalizados, dirígete a Crear conjuntos de orígenes para variantes de compilación.

This site uses cookies to store your preferences for site-specific language and display options.

Get the latest Android developer news and tips that will help you find success on Google Play.

* Required Fields

Hooray!

Browse this site in ?

You requested a page in , but your language preference for this site is .

Would you like to change your language preference and browse this site in ? If you want to change your language preference later, use the language menu at the bottom of each page.

This class requires API level or higher

This doc is hidden because your selected API level for the documentation is . You can change the documentation API level with the selector above the left navigation.

For more information about specifying the API level your app requires, read Supporting Different Platform Versions.

Take a one-minute survey?
Help us improve Android tools and documentation.