Esta página se ha traducido con Cloud Translation API.

Laboratorio de código para desarrolladores de Android

Puedes ayudar a desarrollar el sistema operativo más instalado en la historia de la Tierra. Sí, estás aquí para embarcarte en el viaje de convertirte en ingeniero de plataforma Android.

Aunque el camino es desafiante, el equipo de Android se esfuerza por simplificar su recorrido en cada versión. Y el equipo realiza mejoras todos los días a través del trabajo directo en el Proyecto de código abierto de Android (AOSP).

Así que siéntate, enciende una terminal y hagamos historia.

Objetivos

La misión de este codelab es doble:

Para darle una pequeña muestra de cómo es el flujo de trabajo del desarrollador para los ingenieros de Android que trabajan en la plataforma (el sistema operativo).
Le recomendamos que proporcione comentarios sobre las herramientas, la documentación y el flujo de trabajo del desarrollador de Android.

Requisitos previos

La lista de requisitos para este codelab se deriva de aquellos para el desarrollo de plataforma general ( AOSP ). Para realizar este codelab, configure lo siguiente:

Estación de trabajo física Linux que cumple con todos los requisitos públicos .
Repo y la configuración de Git necesarios para editar el código base de Android.

Ambiente

Normalmente, los usuarios construyen y desarrollan directamente en la estación de trabajo. Debido a que es posible que esté trabajando en varias terminales y muchos de los comandos utilizados son específicos de la terminal, deberá volver a ejecutarlos en cada sesión de terminal. Específicamente, estos incluyen los comandos source build/envsetup.sh y lunch .

Configurar estación de trabajo

Instale los paquetes necesarios en su estación de trabajo.
Mientras aún está en una terminal, instale Repo y obtenga credenciales para todos los repositorios de Git.

Inicializar y sincronizar el código

Navegue a su directorio de inicio:
```
cd ~
```
Cree un subdirectorio de trabajo local dentro de él:
```
mkdir aosp
```
Navegue al directorio:
```
cd aosp
```
Inicialice la rama principal del código fuente del repositorio AOSP (la opción predeterminada):
```
repo init -u https://android.googlesource.com/platform/manifest
```
Ingrese o acepte sus credenciales de Git (nombre, dirección de correo electrónico).
Sincroniza el código fuente:
```
repo sync -j8
```

Las sincronizaciones iniciales pueden tardar una hora o más.

Cada extracción de repositorio está representada por un archivo de manifiesto . Está permitido tener más de un repositorio a la vez, siempre que existan en directorios distintos. Pero tenga en cuenta que cada pago y compilación equivale a aproximadamente 300 GB de uso (y sigue aumentando), así que limítese a 2 pagos de repositorio o aumente su sistema con una unidad secundaria.

SUGERENCIA: Para aumentar el espacio libre, elimine un directorio de sucursal y comience de nuevo desde la creación del directorio, así: rm -rf aosp2.

Construye el código

Para compilar Android, debe seleccionar un tipo de dispositivo de destino para compilar con el comando lunch . Un objetivo es una permutación de dispositivo, como un modelo o factor de forma específico.

El objetivo del dispositivo aosp_cf_x86_64_phone-userdebug le permite crear el dispositivo Android virtual Cuttlefish para realizar pruebas sin un dispositivo físico.

Para crear y actualizar un dispositivo físico, elija otro destino y siga las instrucciones para actualizar dispositivos .

Configure su entorno para construir dispositivos Android ejecutando el siguiente comando desde la raíz de su código fuente:
```
source build/envsetup.sh
```
Pase el objetivo de compilación al comando de almuerzo, así:
```
lunch aosp_cf_x86_64_phone-trunk_staging-userdebug
```
Cree el código desde cualquier lugar de su pago con:
```
m
```

Espere que la primera construcción demore horas. Las compilaciones posteriores toman mucho menos tiempo.

Lanzar Sepia

Cuttlefish es el emulador de Android que se utiliza para probar tus compilaciones.

Si nunca ha instalado Cuttlefish, debe instalar las dependencias de Cuttlefish necesarias. En una ventana de terminal, ejecute los siguientes comandos para descargar, compilar e instalar los paquetes del host Debian:

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 .

Lanzar Sepia:
```
launch_cvd --daemon</code>
```
Conéctese al dispositivo Cuttlefish navegando a https://localhost:8443 en su navegador web. Será recibido con una transmisión de video del dispositivo con Android que acaba de construir.

Hacer un cambio

Actualice el código fuente siguiendo esta lista de cambios de ejemplo.

Desde la raíz de su pago (directorio aosp/ ), navegue hasta el proyecto frameworks/native Git:
```
cd frameworks/native
```
Inicie un proyecto temporal con este comando:
```
repo start <some-name> .
```
Edite SurfaceFlinger.cpp para incluir las actualizaciones de la lista de cambios en la siguiente ubicación:
```
aosp/frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp
```
Encuentra esta línea:
```
postComposition();
```

Reemplace esas dos líneas con lo siguiente:

postComposition();
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});
updateColorMatrixLocked();

Construya el código:
```
m
```

Actualice la compilación en el dispositivo:

adb root
adb remount
adb sync
adb reboot

Verifique que vea un cambio de color en su dispositivo seleccionado similar a lo que se muestra en la Figura 1.

Example of a successful color change

Figura 1. Aspecto de la pantalla después de un cambio de color exitoso

Prueba tu código

Esta parte del codelab utiliza una prueba de ejemplo que está en el árbol de código fuente y está fallando. Esto emplea Atest para ejecutar la prueba localmente y probar el código.

Para utilizar la prueba, siga estas instrucciones:

Correr:
```
atest DevCodelabTest
```
La prueba fallará. Para solucionarlo, busque el código fuente de la prueba fallida:
```
atest --info android.test.example.devcodelab.DevCodelabTest#testHelloWorld
```

Entonces mira aquí

platform_testing/tests/example/devcodelab

Para editar el archivo, tome el nombre de la prueba en android.test.example.devcodelab.DevCodelabTest y reemplace el archivo . con / , para obtener este resultado:
```
src/android/test/example/devcodelab/DevCodelabTest.java
```

Luego edita

platform_testing/tests/example/devcodelab/src/android/test/example/devcodelab/DevCodelabTest.java

para reemplazar

Assert.assertTrue(false)

con

Assert.assertTrue(true)

Ejecute la prueba nuevamente para verificar que solucionó el problema:
```
atest DevCodelabTest
```

Sube tu código para revisión

Repo simplifica el uso de Git al agrupar comandos como git clone para trabajar en numerosos repositorios (o proyectos) de Git a la vez.

Consulte Herramientas de control de código fuente para obtener descripciones generales de Git y Repo, con enlaces a documentación completa sobre cómo trabajar con el código fuente de Android. Consulte el repositorio de AOSP para obtener la lista completa de proyectos de Git y los proyectos individuales (rutas) para las ramas asociadas con cada proyecto.

Para la revisión del código de sus proyectos en Git, utilizará el sistema de revisión de código basado en la web de Gerrit .

Suponiendo que realizó los cambios en los frameworks/native , ejecute estos comandos para cargarlos:
```
cd frameworks/native
repo start codelab .
git add .
git commit
```
Para su mensaje de confirmación, ingrese lo siguiente:
```
Android codelab change
Test: manual atest
```
Sube tu cambio:
```
repo upload
```

Si tiene éxito, verá un mensaje similar a este:

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

Vea su cambio en Gerrit

Vaya al enlace, impreso en la terminal, que se parece a este:

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

Esto completa el laboratorio de código inicial para el desarrollo de la plataforma Android. Consulte Envío de parches para conocer los próximos pasos y, para obtener detalles completos sobre el desarrollo de Android, consulte el resto de este sitio.

Revierte tu cambio

Normalmente, después de la prueba y tras la revisión y aprobación, usted envía su cambio en Gerrit y lo fusiona en el repositorio.

En su lugar, para los fines de este codelab, revierta su lista de cambios haciendo clic en Abandonar en Gerrit.

Luego abandone la rama temporal asociada en el directorio frameworks/native (o sus subdirectorios):

repo abandon codelab .

Recuerde también revertir los cambios que realizó en el archivo de prueba. Como no repo start , git commit y repo upload el cambio, puede restablecer el archivo en sí. Suponiendo que estás en el aosp/platform_testing directory , usa lo siguiente para restablecer el archivo:

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

En este punto, ¡ya terminaste! ¡Buen trabajo!

Consigue ayuda

Si encuentra errores durante este codelab, infórmelo utilizando el enlace de seguimiento de problemas en la parte inferior de cualquier página. Envíe preguntas al grupo de creación de Android .