A partir del 27 de marzo de 2025, te recomendamos que uses android-latest-release en lugar de aosp-main para compilar y contribuir a AOSP. Para obtener más información, consulta Cambios en AOSP.

Cómo probar el desarrollo en Android

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

Configuración para el desarrollo en 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 tengas correctamente instalado el software requerido. También debes conocer los siguientes términos:

Git: Git es un sistema de control de versiones 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 versiones; 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 fuentes de AOSP.

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:

Descarga la información del paquete actual:
```
sudo apt-get update
```
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.
(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.
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 Git tiene todo el historial del código fuente de Android, incluidos los cambios en el código fuente y el momento en que se hicieron. Para descargar el código fuente de Android, haz lo siguiente:

Ve a tu directorio principal:
```
cd ~
```
En su interior, crea un subdirectorio de trabajo local:
```
mkdir aosp
```
Navega al directorio:
```
cd aosp
```
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
```
Ingresa o acepta tus credenciales de Git (nombre, dirección de correo electrónico).
Sincroniza el código fuente:
```
repo sync -c -j8
```
Si tienes algún problema durante una descarga, consulta Cómo corregir errores de sincronización.

Cómo compilar el código

Para compilar el código, haz lo siguiente:

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

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 destino:

lunch aosp_cf_x86_64_phone-trunk_staging-userdebug

Deberías ver una sinopsis 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
============================================

Compila el destino:
```
m
```

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

Cómo iniciar Cuttlefish

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

Ejecuta los siguientes comandos para descargar, compilar y también 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.

Inicia Cuttlefish:
```
launch_cvd --daemon
```
Navega a https://localhost:8443 en tu navegador web para conectarte al dispositivo Cuttlefish. Aparecerá el dispositivo virtual con Android.

Cómo hacer un cambio

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

Desde la raíz de la implementación (directorio aosp/), ve al proyecto frameworks/native de Git:
```
cd frameworks/native
```
Inicia un proyecto temporal con el siguiente comando:
```
repo start <some-name> .
```
Usa tu editor para modificar SurfaceFlinger.cpp en la siguiente ubicación:
```
aosp/frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp
```

Busca esta línea:

void SurfaceFlinger::updateColorMatrixLocked() {

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});

Compila el código:
```
m
```

Actualiza la compilación en el dispositivo:

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

Verifica que se muestre un cambio de color en el dispositivo seleccionado, de forma similar a como se ve 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:

Ejecuta lo siguiente:
```
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.

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.

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 de manera que incluya el nombre del archivo de prueba. Por ejemplo, android.test.example.devcodelab.DevCodelabTest se convierte en WORKING_DIRECTORY/platform_testing/tests/example/devcodelab/src/android/test/example/devcodelab/DevCodelabTest.java.
Edita platform_testing/tests/example/devcodelab/src/android/test/example/devcodelab/DevCodelabTest.java y reemplaza Assert.assertTrue(false) por Assert.assertTrue(true).
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, usarás el sistema Gerrit de revisión de código basado en la Web.

Si hiciste cambios en el proyecto de frameworks/native, ejecuta estos comandos para subirlos:
```
cd frameworks/native
repo start codelab .
git add .
git commit
```
Para tu mensaje de confirmación, ingresa lo siguiente:
```
Android codelab change
Test: manual atest
```

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 a la salida con el 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 combinarlo en el repositorio. En vez de eso, a los efectos de este codelab, revierte tu trabajo:

En Gerrit, haz clic en Abandon.
Abandona la rama temporal asociada del directorio frameworks/native del proyecto (o sus subdirectorios):
```
repo abandon codelab .
```
Revierte los cambios que realizaste en el archivo de prueba. Como no ejecutaste repo start, git commit ni repo upload en el cambio de la prueba, puedes restablecer el archivo. Si estás en 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 sobre desarrollo para la plataforma de Android.

Cómo obtener ayuda

Si encuentras errores durante este codelab, infórmalos a través del vínculo de Issue Tracker 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 crossvm se está ejecutando, escribe stop_cvd || true, o bien, kill crosvm y agrega el PID del proceso.