Crea diferentes versiones de tu app con variantes de compilación

1. Introducción

Última actualización: 14/04/2022

Las variantes de compilación son útiles para crear diferentes versiones de tu app. Por ejemplo, es posible que se conveniente que compiles una versión de tu app que sea sin cargo, con contenido limitado, y una versión paga que incluya más contenido. También puedes compilar diferentes versiones de tu app para diferentes dispositivos, según el nivel de API u otras variantes de dispositivos.

En este codelab, modificarás la app de Dice Roller que compilaste en la unidad 1 de aspectos básicos de Kotlin, para que tengas dos versiones: "demostración" y "completa". La versión "completa" tiene un cuadro de texto adicional que muestra el resultado del lanzamiento del dado en palabras, de modo que el usuario no tenga que depender solo de la imagen del dado para conocer el resultado.

Conocimientos que ya deberías tener

Requisitos:

• Haber completado la ruta de aprendizaje de Aspectos básicos de Android 1-4 Para completar los codelabs requeridos, consulta las rutas de aprendizaje de Unidad 1: Aspectos básicos de Kotlin.
• Conocimientos generales sobre el sistema de compilación de Android. Para familiarizarte con sus componentes principales, consulta la descripción general de la compilación.

Qué aprenderás

• Qué son las variantes de compilación
• Qué son los conjuntos de orígenes
• Cómo compilar diferentes versiones de tu app con variantes de compilación y conjuntos de orígenes
• Cómo asignar ID de aplicación únicos a las variantes de tu aplicación

Qué compilarás

En este codelab, comenzarás con la app de Dice Roller que compilaste en las rutas de aprendizaje de la Unidad 1: Aspectos básicos de Kotlin. La app de Dice Roller tiene una foto de un dado y un botón ROLL debajo de la imagen. Cuando el usuario hace clic en ROLL, se lanza el dado y la imagen cambia según el resultado del lanzamiento.

Puedes crear archivos de proyectos adicionales y agregar código para lo siguiente:

• Crear variantes de producto "demostración" y "completa" de tu app
• Crear conjuntos de orígenes "demostración" y "completa" que correspondan a las variantes de producto
• Agregar un cuadro al diseño de la versión "completa" de tu app
• Programar el cuadro de la versión "completa" para que muestre el resultado del lanzamiento cuando el usuario haga clic en ROLL
• Personalizar los títulos de las apps para las versiones "demostración" y "completa"
• Proporcionar ID de aplicación únicos a las versiones de la app "demostración" y "completa"

Así se verá la versión completa de tu app:

Requisitos

• Android Studio Bumblebee

2. Desarrolla tu entorno

Obtén el código

Si no tienes la app de Dice Roller completa de la Unidad 1: Aspectos básicos de Kotlin, que ya está disponible, descarga el código de la app desde GitHub.

Para descargar y abrir el código de la app en Android Studio, sigue estos pasos:

1. En la página principal del repositorio de GitHub android-basics-kotlin-dice-roller-with-images-app-solution, haz clic en Code > Download ZIP.
2. Una vez que se descargue el archivo ZIP, abre el proyecto en Android Studio y, luego, haz clic en File > Open. Puedes iniciar una actividad vacía o abrir un proyecto anterior si se te solicita. Realmente no importa la opción que elijas, ya que abriremos el proyecto descargado.
3. Navega a la carpeta donde se descarga el archivo ZIP (probablemente tu carpeta Downloads), selecciónalo y haz clic en Open.

Cómo usar la vista Project

Cuando trabajas con variantes de compilación, debes trabajar con tus archivos de proyecto en la vista Project para ver todos los directorios de las diferentes variantes. Para ello, abre el panel Project en Android Studio, haz clic en el menú de tipo de vista (está configurado en Android de forma predeterminada) y selecciona la vista Project.

3. Comprende las variantes de compilación

Las variantes de compilación son el resultado de diferentes combinaciones de variantes de producto y tipos de compilación. Las variantes de producto son atributos más orientados al usuario, mientras que los tipos de compilación son atributos se orientan más a los desarrolladores. En realidad, no debes configurar las variantes de compilación directamente, sino que debes configurar un conjunto de variantes de producto y un conjunto de tipos de compilación, que, a su vez, determinan las variantes de compilación.

En particular, las variantes de compilación representan cada combinación de variante de producto y tipo de compilación, y se denominan <product-flavor><build-type> según corresponda. Por ejemplo, si tienes los tipos de compilación debug y release, y las variantes de producto demo y full, las variantes de compilación resultantes serán las siguientes:

• demoDebug
• demoRelease
• fullDebug
• fullRelease

A continuación, vamos a configurar nuestras variantes de productos y tipos de compilación para la app de DiceRoller.

4. Configura los tipos de productos

Las variantes de producto son los atributos que se orientan más a los usuarios de tu app en el sentido de que, en general, representan las versiones de la app disponibles para ellos. Para crear las versiones "demostración" y "completa" de nuestra app, debes agregar las dos variantes de productos y asignarlas a una dimensión de variantes. Si quieres agregar las variantes de producto, abre el archivo build.gradle a nivel de la app (app > build.gradle en la vista Project) y pega este código en el bloque android {}.

flavorDimensions "app_type"
productFlavors {
   demo {
       dimension "app_type"
         }
   full {
       dimension "app_type"
   }
}

Este código hace lo siguiente:

• Crea una dimensión de variantes llamada app_type.
• Crea dos variantes de producto, representadas por los bloques demo {} y full {}.
• Asigna las dos variantes de producto a la dimensión app_type (este paso es opcional si hay una sola dimensión de variantes).

Este es el código básico que se necesita para definir variantes de producto. Usarás algunas opciones adicionales más adelante en este codelab.

5. Configura los tipos de compilaciones

Los tipos de compilación son los atributos más orientados a los desarrolladores de tu app en el sentido de que, en general, representan etapas de desarrollo (por ejemplo, depuración, beta y lanzamiento). Android Studio configura automáticamente dos tipos de compilación: debug y release. El tipo de compilación debug es para fines de depuración, mientras que el tipo de compilación release es para fines de distribución.

Puedes crear tipos de compilación y modificar su configuración editando el bloque buildTypes {} en el archivo build.gradle a nivel de la app. El bloque buildTypes {} predeterminado es el siguiente:

buildTypes {
   release {
       minifyEnabled false
       proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
   }
}

Puedes ver la configuración predeterminada del tipo de compilación release (no se abarcarán las propiedades minifyEnabled ni proguardFiles en este codelab). El tipo de compilación debug no aparece en el archivo de configuración de compilación de forma predeterminada, pero puedes agregar un bloque debug {} para agregar o cambiar determinados parámetros de configuración. La configuración predeterminada funciona para nuestros fines, así que puedes dejarla como está.

6. Usa la ventana de herramientas de variantes de compilación

Ahora que tienes dos variantes de producto y dos tipos de compilación, veamos las variantes de compilación que crean. Para ver tus nuevas variantes de compilación en Android Studio, haz lo siguiente:

1. En la barra de herramientas, haz clic en Sync Project with Gradle Files . Cada vez que realices cambios en los archivos de la configuración de la compilación, Studio te solicitará que sincronices tus archivos para poder guardar la nueva configuración de compilación y comprobar si hay errores en ella.
2. Haz clic en Build > Select Build Variant (o View > Tool Windows > Build Variants) para mostrar la ventana Build Variants.
3. Haz clic en demoDebug en la columna Active Build Variant para abrir un menú que contenga todas sus variantes de compilación: demoDebug, demoRelease, fullDebug y fullRelease. Usa este menú a fin de seleccionar diferentes variantes de compilación para ejecutarlas y probarlas.

Ejecuta las variantes demoDebug y fullDebug (las variantes basadas en el tipo de compilación release requieren más configuración para ejecutarse, por lo que no las abordaremos en este codelab). Hasta ahora, las variantes demoDebug y fullDebug no pueden distinguirse desde la perspectiva del usuario.

7. Crea diferentes funciones para variantes diferentes

Ahora que tienes las versiones de "demostración" y "completa" de la app, agregaremos algunas funciones a la versión completa.

Cómo agregar una función premium con conjuntos de orígenes

Para la variante de producto full, agregaremos un cuadro que muestre el resultado del lanzamiento, de modo que los usuarios no tengan que depender solo de la imagen del dado para saber lo que lanzaron. Para agregar esta función premium, usa conjuntos de orígenes. Un conjunto de orígenes es un directorio que incluye contenido para tipos de compilación, variantes de producto y variantes de compilación específicos. El conjunto de orígenes main predeterminado (app > src > main) incluye contenido para compartir entre todas las variantes de compilación. Este contenido predeterminado se puede anular con contenido de otros conjuntos de orígenes.

La forma de anular el contenido del conjunto de orígenes main y de determinar los conjuntos de orígenes que debes agregar varía según lo que desees cambiar.

Para cambiar un recurso, como un diseño o una imagen (en main > res), sigue estos pasos generales:

1. Crea un conjunto de orígenes (directorio) para la variante de producto que quieras cambiar (veremos dónde y cómo crear este conjunto de orígenes en la próxima sección).
2. Pega el archivo de recursos que deseas cambiar en este nuevo conjunto de orígenes y, luego, actualízalo. Cuando el complemento de Android para Gradle (AGP) compila una variante de compilación que depende del nuevo conjunto de orígenes, anula el código de recursos en main con el código de recursos del nuevo conjunto de orígenes.

Para anular un comportamiento en una clase de Java o Kotlin (en main > java), sigue estos pasos generales:

1. Crea conjuntos de orígenes (directorios) para la variante de producto que quieras cambiar y todas las demás variantes de producto en la misma dimensión de variantes.
2. Pega el archivo que desees cambiar en todos los conjuntos de orígenes de la variante de producto y, luego, modifica las copias que quieras cambiar.
3. Borra el archivo original del conjunto de orígenes main.

Para agregar un cuadro dinámico a la versión completa de tu app, piensa en la función premium como dos ediciones principales:

• Personaliza el diseño: Agrega un cuadro modificando el archivo activity_main.xml.
• Personaliza el comportamiento de la app: Modifica el archivo MainActivity.kt para cambiar lo que se muestra en el cuadro según el lanzamiento del dado.

En la siguiente sección, aprenderás dónde y cómo crear conjuntos de orígenes.

Cómo determinar dónde crear nuevos conjuntos de orígenes

El complemento de Android para Gradle (AGP) te muestra la manera de organizar tus archivos para cada tipo de compilación, variante de producto y variante de compilación. Para agregar una función premium a la variante de producto full que incluya un cambio en el archivo MainActivity.kt, crea conjuntos de orígenes para las variantes full y demo. Para descubrir dónde crear estos conjuntos de orígenes, sigue estos pasos en Android Studio:

1. Haz clic en Gradle en la ventana del IDE.
2. Navega a MyApplication > Tasks > android y haz doble clic en sourceSets. Si no ves la carpeta Tasks, permite que Gradle compile la lista de tareas durante la sincronización. Para ello, haz clic en File > Settings > Experimental y desmarca Do not build Gradle task list during Gradle sync (Android Studio > Preferences > Experimental en macOS). Una vez que Gradle ejecute la tarea, la ventana Run debería mostrar el resultado.
3. Si la pantalla no está en modo texto, como se muestra aquí, haz clic en Toggle view en la ventana Run.

En la ventana Run, deberías ver este resultado:

------------------------------------------------------------
Project ':app'
------------------------------------------------------------

...

debug
-----
Compile configuration: debugCompile
build.gradle name: android.sourceSets.debug
Java sources: [app/src/debug/java]
Kotlin sources: [app/src/debug/kotlin, app/src/debug/java]
Manifest file: app/src/debug/AndroidManifest.xml
Android resources: [app/src/debug/res]
Assets: [app/src/debug/assets]
AIDL sources: [app/src/debug/aidl]
RenderScript sources: [app/src/debug/rs]
JNI sources: [app/src/debug/jni]
JNI libraries: [app/src/debug/jniLibs]
Java-style resources: [app/src/debug/resources]

...

full
----
Compile configuration: fullCompile
build.gradle name: android.sourceSets.full
Java sources: [app/src/full/java]
Kotlin sources: [app/src/full/kotlin, app/src/full/java]
Manifest file: app/src/full/AndroidManifest.xml
Android resources: [app/src/full/res]
Assets: [app/src/full/assets]
AIDL sources: [app/src/full/aidl]
RenderScript sources: [app/src/full/rs]
JNI sources: [app/src/full/jni]
JNI libraries: [app/src/full/jniLibs]
Java-style resources: [app/src/full/resources]

En la lista de rutas de acceso a archivos en "debug", se describe dónde AGP busca los recursos y el código de la app para la variante de producto "debug" de forma predeterminada. Del mismo modo, la lista de rutas de acceso a archivos en "full" describe dónde AGP busca contenido para la variante de producto "full" de forma predeterminada.

Toma nota de las rutas de acceso a archivos de "fuentes de Java" (para archivos como las clases Java y Kotlin) y "recursos de Android" (para archivos como imágenes y diseños). Ahora que ya sabes dónde crear nuevos conjuntos de orígenes, créalos y agrega código para la función premium.

Cómo personalizar el diseño de la versión completa

Para agregar un cuadro a la versión completa de tu app, sigue estos pasos:

Primero, crea el conjunto de orígenes full y el directorio de recursos de Java:

1. Abre el panel Project y selecciona la vista Project.
2. Navega al directorio DiceRoller/app/src/.
3. Haz clic con el botón derecho en el directorio src y selecciona New > Directory.
4. En el menú de Gradle Source Sets, selecciona full/resources y, luego, presiona Enter.

Luego, pega el archivo activity_main.xml del conjunto de orígenes main al conjunto de orígenes full.

1. Navega a DiceRoller/app/src/main/res/.
2. Haz clic con el botón derecho en el archivo activity_main.xml y, luego, en Copy.
3. Navega a DiceRoller/app/src/full/res/.
4. Haz clic con el botón derecho en el directorio res y, luego, en Paste.

En tercer lugar, para agregar un cuadro a la variante full de tu app, agrega este código al archivo activity_main.xml en el conjunto de orígenes full:

<TextView
    android:id="@+id/resultTextView"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:textSize="16sp"
    android:text="Result"
    app:layout_constraintBottom_toTopOf="@+id/button"
    app:layout_constraintEnd_toEndOf="parent"
    app:layout_constraintStart_toStartOf="parent"
    app:layout_constraintTop_toBottomOf="@id/imageView" />

Ejecuta las variantes de compilación fullDebug y demoDebug de tu app (selecciona la variante de compilación que desees ejecutar mediante la ventana de herramientas Build Variants y, luego, haz clic en Run). Deberías ver el nuevo cuadro solo para la variante fullDebug. Sin embargo, el cuadro aún no realiza ninguna acción, así que prográmalo para que cambie en función del dado.

Cómo personalizar el comportamiento de la versión completa

En la versión completa de la app, el cuadro debe mostrar el resultado del lanzamiento del anuncio, en palabras. Para habilitar este comportamiento, haz lo siguiente:

Primero, crea el directorio de fuentes de Java del conjunto de orígenes full.

1. Con el panel Project en la vista Project, navega al directorio DiceRoller/app/src/full.
2. Haz clic con el botón derecho en el directorio full y selecciona New > Directory.
3. En el menú Gradle Source Sets, selecciona java y, luego, presiona Enter.

Segundo, crea el conjunto de orígenes debug y el directorio de fuentes de Java.

1. Con el panel Project en la vista Project, navega al directorio DiceRoller/app/src.
2. Haz clic con el botón derecho en el directorio src y selecciona New > Directory.
3. En el menú Gradle Source Sets, selecciona debug/java y, luego, presiona Enter.

En tercer lugar, navega al directorio DiceRoller/app/src/main/java.

1. Pega el archivo MainActivity.kt en los directorios full/java y debug/java.
2. Borra el directorio java, incluido el archivo MainActivity.kt, del conjunto de orígenes principal (haz clic con el botón derecho en el directorio java y, luego, en Delete).
3. En el archivo MainActivity.kt del conjunto de orígenes completo, agrega este código al método rollDice():

// Update the result text view
val resultTextView: TextView = findViewById(R.id.resultTextView)
resultTextView.text = when (diceRoll) {
    1 -> "One"
    2 -> "Two"
    3 -> "Three"
    4 -> "Four"
    5 -> "Five"
    else -> "Six"
}

Vuelve a ejecutar las variantes de compilación fullDebug y demoDebug. El cuadro de la versión completa debe incluir el resultado del lanzamiento.

Cómo cambiar los títulos de las apps

Para mayor claridad, especifiquemos la versión de la app que usas en el título de la app. Este tipo de cambio puede realizarse sin conjuntos de orígenes. El título de la app se define según la propiedad label en el archivo AndroidManifest.xml (app > manifests > AndroidManifest.xml). A fin de obtener el valor label que cambiará según la variante que se ejecute, abre el archivo AndroidManifest.xml y cambia la línea de etiqueta de la siguiente manera:

android:label="${appLabel}"

De esta manera, se asigna una variable, appLabel, como título de la app.

A continuación, para establecer el valor de appLabel o cambiar el título de la versión de demostración de la app, agrega la línea manifestPlaceholders al bloque demo {} que creaste antes:

demo {
   dimension "version"
   manifestPlaceholders = [appLabel: "Dice Roller - Demo"]
   applicationIdSuffix ".demo"
}

Del mismo modo, para cambiar el título de la variante full de la app, agrega otra línea manifestPlaceholders al bloque full {}:

full {
   dimension "version"
   manifestPlaceholders = [appLabel: "Dice Roller - Full"]
   applicationIdSuffix ".full"
}

Vuelve a ejecutar las variantes demoDebug y fullDebug. Ahora deberías ver los diferentes títulos de las diferentes variantes de compilación.

8. Brinda ID de aplicación únicos a las variantes de compilación

Cuando compilas un APK o un AAB para tu app, las herramientas de compilación etiquetan la app con el ID de aplicación definido en el bloque defaultConfig {} del archivo build.gradle en el nivel de la app (como se muestra a continuación). Sin embargo, si deseas crear diferentes versiones de tu app para que aparezcan como fichas separadas en Google Play Store, como una versión "demostración" o "completa", debes asignar un ID de aplicación diferente a cada una. Para cada variante del bloque productFlavors {}, puedes volver a definir la propiedad applicationId o, en su lugar, agregar un segmento al ID de aplicación predeterminado usando el objeto applicationIdSuffix, como se muestra aquí:

defaultConfig {
   applicationId "com.example.diceroller"
   ...
}

flavorDimensions "version"
productFlavors {
   demo {
 dimension "version"
       manifestPlaceholders = [appLabel: "Dice Roller - Demo"]
         applicationIdSuffix ".demo"
   }
   full {
       dimension "version"
       manifestPlaceholders = [appLabel: "Dice Roller - Full"]
         applicationIdSuffix ".full"
   }
}

9. Felicitaciones

¡Felicitaciones! Compilaste correctamente dos versiones de la app de Dice Roller con variantes de compilación.

Configuraste variantes de producto y tipos de compilación para crear variantes de compilación. Usaste conjuntos de orígenes para agregar una función premium a la versión "completa" de la app. Aprendiste a asignar a cada variante de compilación un ID de aplicación único para que se consideren apps independientes en Play Store.

Ahora, conoces los pasos fundamentales que se necesitan para crear varias versiones de una app a fin de ofrecer un mejor servicio a diferentes grupos de usuarios.

¿Qué sigue?

• Cómo publicar tu app

Documentos de referencia

• Cómo configurar tu compilación
• Cómo configurar variantes de compilación