Prueba el desarrollo de Android

Este instructivo te permite probar el desarrollo del sistema operativo Android por primera vez.

Configuración para el desarrollo de Android

Antes de descargar y compilar la rama main de la fuente de Android, asegúrate de que tu hardware cumpla con los requisitos necesarios y de que el software requerido esté instalado correctamente. También debes conocer los siguientes términos:

Git

Git es un sistema de control de versión distribuido, gratuito y de código abierto. Android lo usa para operaciones locales como ramificaciones, confirmaciones, diferencias y ediciones. Si deseas obtener ayuda para aprender sobre Git, consulta la documentación de Git.

Repo

Repo es un wrapper de Python para Git que simplifica la ejecución de operaciones complejas en varios repositorios de Git. Repo no reemplaza Git para todas las operaciones de control de versión; solo facilita la realización de operaciones complejas de Git. Usa archivos de manifiesto para agregar proyectos de Git al superproyecto de Android.

archivo de manifiesto

Un archivo de manifiesto es un archivo en formato XML que especifica dónde se ubican los varios proyectos de Git en la fuente de Android dentro del árbol de fuente de AOSP.

Nota: Todos los comandos de esta página están precedidos por un signo de dólar ($) para diferenciarlos de las salidas o entradas dentro de los archivos. Para copiar un comando en el portapapeles, haz clic en el ícono Copiar la muestra de código en la parte superior derecha de cada cuadro de comando.

Cumple con los requisitos de hardware

Tu estación de trabajo de desarrollo debe cumplir o superar estos requisitos de hardware:

• Sistema x86 de 64 bits

  Nota: Puedes compilar versiones de AOSP anteriores a 2.3.x en sistemas de 32 bits.

• Al menos 400 GB de espacio libre en el disco para verificar y compilar el código (250 GB para la verificación y 150 GB para la compilación).

  Nota: Necesitas más espacio para verificar una duplicación, ya que las duplicaciones completas del Proyecto de código abierto de Android (AOSP) contienen todos los repositorios de Git que se usaron alguna vez.

• Al menos 64 GB de RAM. Google usa máquinas de 72 núcleos con 64 GB de RAM para compilar Android. Con esta configuración de hardware, una compilación completa de Android toma aproximadamente 40 minutos, y una compilación incremental solo toma unos pocos minutos. En cambio, con una máquina de 6 núcleos y 64 GB de RAM, una compilación completa demora cerca de 6 horas.

Cumple con los requisitos del sistema operativo

Tu estación de trabajo de desarrollo debe ejecutar cualquier distribución de Linux de 64 bits con la biblioteca GNU C (glibc) 2.17 o una versión posterior.

Instala los paquetes obligatorios

Para instalar los paquetes obligatorios para Ubuntu 18.04 o versiones posteriores, ejecuta el siguiente comando:

sudo apt-get install git-core gnupg flex bison build-essential zip curl zlib1g-dev libc6-dev-i386 x11proto-core-dev libx11-dev lib32z1-dev libgl1-mesa-dev libxml2-utils xsltproc unzip fontconfig

Instala el software obligatorio

Para poder trabajar con AOSP, debes tener instalados OpenJDK, Make, Python 3 y Repo. La rama principal de AOSP viene con versiones precompiladas de OpenJDK, Make y Python 3, por lo que no necesitarás realizar pasos de instalación adicionales. En la siguiente sección, se explica cómo instalar Repo.

Cómo instalar Repo

Sigue estos pasos para instalar Repo:

1. Descarga la información del paquete actual:

   sudo apt-get update

2. Ejecuta el siguiente comando para instalar el Launcher de Repo:

   sudo apt-get install repo

   El Launcher de Repo ofrece una secuencia de comandos de Python que inicializa un procesamiento y descarga la herramienta Repo completa.

   Si se realiza de forma correcta, continúa con el paso 4.

3. (Opcional) Instala Repo de forma manual usando la siguiente serie de comandos:

   export REPO=$(mktemp /tmp/repo.XXXXXXXXX)
   curl -o ${REPO} https://storage.googleapis.com/git-repo-downloads/repo
   gpg --recv-keys 8BB9AD793E8E6153AF0F9A4416530D5E920F5C65
   curl -s https://storage.googleapis.com/git-repo-downloads/repo.asc | gpg --verify - ${REPO} && install -m 755 ${REPO} ~/bin/repo

   Los primeros tres comandos configuran un archivo temporal, descargan Repo en el archivo y verifican que la clave proporcionada coincida con la requerida. Si estos comandos se ejecutan de forma correcta, el comando final instala el Launcher de Repo.

4. Verifica la versión del Launcher de Repo:

   repo version

   El resultado debería mostrar la versión 2.4 o una posterior, por ejemplo:

   repo launcher version 2.45

Cómo descargar el código fuente de Android

El código fuente de Android se encuentra en una colección de repositorios Git alojados en Google. Cada repositorio de Git incluye todo el historial del código fuente de Android, lo que incluye los cambios en el código fuente y el momento en que se hicieron. Para descargar la fuente de Android, haz lo siguiente:

1. Ve a tu directorio principal:

   cd ~

2. En su interior, crea un subdirectorio de trabajo local:

   mkdir aosp

3. Navega al directorio:

   cd aosp

4. Inicializa la rama principal del código fuente del repositorio de AOSP (opción predeterminada):

   repo init --partial-clone -b main -u https://android.googlesource.com/platform/manifest

5. Ingresa o acepta tus credenciales de Git (nombre, dirección de correo electrónico).

6. Sincroniza el código fuente:

   repo sync -c -j8

   Si tienes algún problema durante la descarga, consulta Cómo solucionar problemas y corregir errores de sincronización.

Cómo compilar el código

Para compilar el código, haz lo siguiente:

1. Desde tu directorio de trabajo, obtén la secuencia de comandos envsetup.sh para configurar el entorno de compilación.

   source build/envsetup.sh

2. Especifica un tipo de dispositivo de destino para compilar con el comando lunch. Un destino es una permutación de dispositivo, como un modelo o factor de forma específicos. Especifica este objetivo:

   lunch aosp_cf_x86_64_phone-trunk_staging-userdebug

   Deberías ver un resumen de tu destino y entorno de compilación:

   ============================================
   PLATFORM_VERSION_CODENAME=VanillaIceCream
   PLATFORM_VERSION=VanillaIceCream
   PRODUCT_INCLUDE_TAGS=com.android.mainline
   TARGET_PRODUCT=aosp_arm
   TARGET_BUILD_VARIANT=eng
   TARGET_ARCH=arm
   TARGET_ARCH_VARIANT=armv7-a-neon
   TARGET_CPU_VARIANT=generic
   HOST_OS=linux
   HOST_OS_EXTRA=Linux-6.5.13-1rodete2-amd64-x86_64-Debian-GNU/Linux-rodete
   HOST_CROSS_OS=windows
   BUILD_ID=AOSP.MAIN
   OUT_DIR=out
   ============================================
   

3. Compila el destino:

   m

Es posible que la primera compilación tarde varias horas. Las compilaciones posteriores toman mucho menos tiempo. El resultado de la compilación aparece en $OUT_DIR.

Cómo iniciar Cuttlefish

Cuttlefish es el emulador de Android que se usa para probar las compilaciones.

1. Ejecuta los siguientes comandos para descargar, compilar y, luego, instalar los paquetes de Debian del host:

   sudo apt install -y git devscripts equivs config-package-dev debhelper-compat golang curl
   git clone https://github.com/google/android-cuttlefish
   cd android-cuttlefish
   for dir in base frontend; do
   pushd $dir
   # Install build dependencies
   sudo mk-build-deps -i
   dpkg-buildpackage -uc -us
   popd
   done
   sudo dpkg -i ./cuttlefish-base_*_*64.deb || sudo apt-get install -f
   sudo dpkg -i ./cuttlefish-user_*_*64.deb || sudo apt-get install -f
   sudo usermod -aG kvm,cvdnetwork,render $USER
   sudo reboot

   El reinicio activa la instalación de módulos de kernel adicionales y aplica reglas udev.

2. Inicia Cuttlefish:

   launch_cvd --daemon
   

3. Navega a https://localhost:8443 en tu navegador web para conectarte al dispositivo Cuttlefish. Aparecerá tu dispositivo virtual con Android.

Cómo hacer un cambio

Actualiza el código fuente según esta lista de cambios de ejemplo.

1. Desde la raíz de la implementación (directorio aosp/), ve al proyecto frameworks/native de Git:

   cd frameworks/native

2. Inicia un proyecto temporal mediante el siguiente comando:

   repo start <some-name> .

3. Usa tu editor para editar SurfaceFlinger.cpp en la siguiente ubicación:

   aosp/frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp
   

4. Busca esta línea:

   void SurfaceFlinger::updateColorMatrixLocked() {
   

5. Agrega esta línea al comienzo de updateColorMatrixLocked():

   mClientColorMatrix = mat4(vec4{1.0f, 0.0f, 0.0f, 0.0f}, vec4{0.0f, -1.0f, 0.0f, 0.0f},
                             vec4{0.0f, 0.0f, -1.0f, 0.0f}, vec4{0.0f, 1.0f, 1.0f, 1.0f});
   

6. Compila el código:

   m

7. Actualiza la compilación en el dispositivo:

   adb root
   adb remount -R
   adb root
   adb sync
   adb reboot

8. Verifica que veas un cambio de color en el dispositivo seleccionado, similar al que se muestra en la Figura 1.

   

   Figura 1: Apariencia de la pantalla después de un cambio de color exitoso

Cómo corregir una prueba

Esta parte del codelab utiliza una prueba de ejemplo que se encuentra en el árbol de fuentes y que presenta errores.

Para ejecutar, depurar y corregir la prueba, sigue estas instrucciones:

1. Ejecuta:

   atest DevCodelabTest

   La prueba falla.

   Nota: atest es una herramienta de línea de comandos que te permite compilar, instalar y ejecutar pruebas de Android de forma local.

2. Examina el seguimiento de pila de la prueba que falló:

   STACKTRACE:
   java.lang.AssertionError
    at org.junit.Assert.fail(Assert.java:87)
    at org.junit.Assert.assertTrue(Assert.java:42)
    at org.junit.Assert.assertTrue(Assert.java:53)
    at android.test.example.devcodelab.DevCodelabTest.testHelloWorld(DevCodelabTest.java:29)

   La última línea del seguimiento de pila muestra la prueba que falla (testHelloWorld). Esta prueba se encuentra en un archivo llamado DevCodelabTest.java.

3. Para determinar la ubicación de la prueba que se debe corregir, agrega WORKING_DIRECTORY/platform_testing/tests/example/devcodelab/src/ a la última línea del seguimiento de pila hasta el nombre del archivo de prueba inclusive. Por lo tanto, android.test.example.devcodelab.DevCodelabTest se convierte en WORKING_DIRECTORY/platform_testing/tests/example/devcodelab/src/android/test/example/devcodelab/DevCodelabTest.java.

4. Edita platform_testing/tests/example/devcodelab/src/android/test/example/devcodelab/DevCodelabTest.java y reemplaza Assert.assertTrue(false) por Assert.assertTrue(true).

5. Vuelve a ejecutar la prueba para verificar que se haya corregido el problema:

   atest DevCodelabTest

Cómo subir el código para revisión

Repo simplifica el uso de Git agrupando comandos como git clone para aplicarlos en varios repositorios (o proyectos) de Git al mismo tiempo.

Para la revisión de código de tus proyectos en Git, usa el sistema Gerrit de revisión de código basado en la Web.

Importante: Asegúrate de haber accedido a Gerrit para ver los cambios y responder a ellos.

1. Si hiciste cambios en el proyecto de frameworks/native, ejecuta estos comandos para subirlos:

   cd frameworks/native
   repo start codelab .
   git add .
   git commit

2. Para tu mensaje de confirmación, ingresa lo siguiente:

   Android codelab change
   Test: manual atest
   

3. Sube el cambio:

   repo upload

   Si lo haces correctamente, verás un mensaje similar al siguiente:

   Upload project frameworks/native/ to remote branch main:
    branch codelab ( 1 commit, Wed Aug 7 09:32:33 2019 -0700):
           ff46b36d android codelab change
   to https://android-review.googlesource.com/ (y/N)? y
   remote: Processing changes: refs: 1, new: 1, done
   remote:
   remote: SUCCESS
   remote:
   remote:   https://android-review.googlesource.com/c/platform/frameworks/native/+/1098432 android codelab change [NEW]
   remote:
   To https://android-review.googlesource.com/platform/frameworks/native
   * [new branch]          codelab -> refs/for/main
   

Cómo ver el cambio en Gerrit

Para ver el cambio en Gerrit, navega al resultado del vínculo en la terminal. El vínculo es similar al siguiente:

https://android-review.googlesource.com/c/platform/frameworks/native/+/1098432

Cómo revertir el cambio

Por lo general, después de la prueba y al momento de la revisión y aprobación, debes enviar el cambio en Gerrit y fusionarlo en el repositorio. En su lugar, a los efectos de este codelab, revierte tu trabajo:

1. En Gerrit, haz clic en Abandon.

2. Abandona la rama temporal asociada del directorio frameworks/native del proyecto (o sus subdirectorios):

   repo abandon codelab .

3. Revierte los cambios que hiciste en el archivo de prueba. Como no ejecutaste repo start, git commit ni repo upload en el cambio de prueba, puedes restablecer el archivo en sí. Si estás en el aosp/platform_testing directory, usa el siguiente comando para restablecer el archivo:

   git reset HEAD tests/example/devcodelab/src/android/test/example/devcodelab/DevCodelabTest.java
   git checkout .

De esta manera finaliza el codelab de desarrollo para la plataforma de Android.

Obtener ayuda

Si encuentras errores durante este codelab, infórmalos a través del vínculo de Herramienta de seguimiento de errores que se encuentra en la parte inferior de cualquier página. Envía preguntas al grupo android-building.

Escribe ps -A | grep crosvm para ver si crosvm ya se está ejecutando. Si se está ejecutando crossvm, escribe el proceso stop_cvd || true o kill crosvm con el PID del proceso.