Se usó la API de Cloud Translation para traducir esta página.

Laboratorio de programación de desarrolladores de Android

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

Aunque el camino es desafiante, el equipo de Android se esfuerza por simplificar su viaje, en cada lanzamiento. 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éntese, encienda una terminal y hagamos historia.

Metas

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).
Anímelo a 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 los del desarrollo de la plataforma general ( AOSP ). Para tomar este codelab, configura lo siguiente:

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

Ambiente

Por lo general, los usuarios construyen y desarrollan en la estación de trabajo directamente. Debido a que puede estar trabajando en varios terminales, y muchos de los comandos utilizados son específicos del 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
```
Navega al directorio:
```
cd aosp
```
Inicialice la rama maestra del código fuente del repositorio AOSP (la 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 pago de repositorio está representado por un archivo de manifiesto . Está permitido tener más de 1 pago de repositorio a la vez, siempre que existan en directorios distintos. Pero tenga en cuenta que cada pago y compilación equivale a un uso de aproximadamente 300 GB (y sigue creciendo), así que limítese a 2 pagos de repositorio o aumente su sistema con una unidad secundaria.

CONSEJO: 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 específico o factor de forma.

El objetivo del dispositivo que se incluye a continuación, aosp_cf_x86_64_phone-userdebug , le permite compilar 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 dispositivos flash .

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

Espere que la primera compilación tome horas. Las compilaciones posteriores toman mucho menos tiempo.

Crear una instancia de Acloud

Acloud es una herramienta de línea de comandos en AOSP que ayuda a los usuarios a crear dispositivos Android virtuales, en este caso, Cuttlefish.

Si está en la misma sesión de terminal que se usó para compilar el código , continúe. De lo contrario, vuelva a ejecutar el script envsetup.sh y el mismo comando de lunch que usó allí primero. Después

Cree una instancia local de Acloud con:

acloud create --local-image --local-instance

Acepte las actualizaciones de los paquetes necesarios.
Si se le solicita, reinicie su estación de trabajo para que todos los cambios surtan efecto.
Selecciona el dispositivo Cuttlefish.

¡Debería ser recibido con una sesión de VNC que contiene un dispositivo Android!

Puede interactuar con el dispositivo virtual en su estación de trabajo usando su mouse y teclado. También puede seguir la actividad dentro de los registros mientras usa su dispositivo empleando el comando logcat de Android Debug Bridge (adb):

adb logcat

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 estas dos líneas:
```
postFrame();
postComposition();
```

Reemplace esas dos líneas con lo siguiente:

postFrame();
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();

Construye el código:
```
m
```

Actualice la compilación en el dispositivo:

adb root
adb remount
adb sync
adb reboot
acloud reconnect

Si se le solicita que seleccione un dispositivo, elija el que muestre el tiempo transcurrido más corto. (Este es probablemente el último en la lista que ve). Para ver todas las instancias de dispositivos virtuales, use los acloud list y acloud list -v .

Verifique que vea un cambio de color en su dispositivo seleccionado similar al 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 laboratorio de código 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 usar 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 . 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)

Vuelva a ejecutar la prueba para verificar que solucionó el problema:
```
atest DevCodelabTest
```

Sube tu código para revisar

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 información general sobre Git y Repo, con enlaces a la documentación completa sobre cómo trabajar con el código fuente de Android. Consulte el repositorio de AOSP para ver la lista completa de proyectos de Git y los proyectos individuales (rutas) para las ramas asociadas con cada proyecto.

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

Suponiendo que haya realizado 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 parecido a este:

Upload project frameworks/native/ to remote branch master:
  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/master

Ver tu 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 codelab 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 después de la revisión y aprobación, envía su cambio en Gerrit y lo fusiona con el repositorio.

En su lugar, para los fines de este laboratorio de código, revierta su lista de cambios haciendo clic en Abandonar en Gerrit.

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

repo abandon codelab .

Recuerde también revertir los cambios que realizó en el archivo de prueba. Como no realizó el repo start , git commit y repo upload el cambio, puede restablecer el archivo en sí. Suponiendo que se encuentra en el aosp/platform_testing directory , use 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 está! ¡Buen trabajo!

Consigue ayuda

Si encuentra errores durante este laboratorio de código, infórmenos mediante el enlace Rastreador de problemas en la parte inferior de cualquier página. Envíe preguntas al grupo de creación de Android .