Codelab para desarrolladores de Android

Puedes ayudar a desarrollar el sistema operativo más instalado de la historia. Sí, estás aquí para emprender el camino que te convertirá en ingeniero de la plataforma de Android.

Si bien el recorrido es desafiante, el equipo de Android se esfuerza por simplificar el camino con cada lanzamiento. Además, trabaja a diario directamente en el Proyecto de código abierto de Android (AOSP) para realizar mejoras.

Por eso relájate, enciende una terminal y hagamos historia.

Objetivos

Este codelab tiene dos objetivos:

Darte una idea de cómo es el flujo de trabajo de desarrollo para los ingenieros de Android que trabajan en la plataforma (el sistema operativo)
Te recomendamos que envíes comentarios sobre las herramientas, la documentación y el flujo de trabajo de desarrollo para Android.

Requisitos previos

La lista de requisitos para este codelab se deriva de los requisitos para el desarrollo de plataformas en general (AOSP). A fin de completar este codelab, configura lo siguiente:

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

Entorno

Por lo general, los usuarios compilan y desarrollan en la estación de trabajo directamente. Dado que es posible que estés trabajando en diferentes terminales y que muchos de los comandos utilizados sean específicos de una terminal, deberás volver a ejecutarlos en cada sesión de terminal. Se incluyen específicamente los comandos source build/envsetup.sh y lunch.

Cómo configurar la estación de trabajo

Instala los paquetes necesarios en tu estación de trabajo.
Desde la terminal, instala Repo y obtén las credenciales para todos los repositorios de Git.

Cómo inicializar y sincronizar el código

Ve a tu directorio principal:
```
cd ~
```
En su interior, crea un subdirectorio de trabajo local:
```
mkdir aosp
```
Ve al directorio:
```
cd aosp
```
Inicializa la rama principal del código fuente del repositorio de AOSP (opción predeterminada):
```
repo init -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 -j8
```

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

Cada implementación de repo se representa con un archivo de manifiesto. Podrás tener más de 1 implementación de Repo a la vez, siempre y cuando estas se encuentren en distintos directorios. Sin embargo, ten en cuenta que cada implementación y compilación equivale a unos 300 GB o más de uso. Por lo tanto, limita la cantidad a 2 o aumenta el sistema con una unidad secundaria.

SUGERENCIA: Para liberar espacio, borra el directorio de una rama y vuelve a comenzar desde la creación del directorio, como se muestra a continuación: rm -rf aosp2.

Cómo compilar el código

Para compilar Android, selecciona un tipo de dispositivo de destino a fin de compilar con el comando lunch. Un destino es una permutación de dispositivo, como un modelo o factor de forma específicos.

La segmentación por dispositivo incluida a continuación, aosp_cf_x86_64_phone-userdebug, te permite compilar el dispositivo Android virtual Cuttlefish a los efectos de realizar pruebas sin un dispositivo físico.

Si, por el contrario, deseas compilar y actualizar un dispositivo físico, elige otro destino y sigue las instrucciones para escribir en la memoria flash de dispositivos.

Configura el entorno a fin de compilar dispositivos Android. Para ello, ejecuta el siguiente comando desde la raíz de la implementación del código fuente:
```
source build/envsetup.sh
```
Pasa el objetivo de compilación al comando de lanzamiento de la siguiente manera:
```
lunch aosp_cf_x86_64_phone-userdebug
```
Compila el código desde cualquier parte de la implementación con lo siguiente:
```
m
```

Es posible que la primera compilación tarde varias horas. Las compilaciones posteriores toman mucho menos tiempo.

Cómo crear una instancia de Acloud

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

Si estás en la misma sesión de terminal que usaste para compilar el código, continúa. De lo contrario, vuelve a ejecutar la secuencia de comandos envsetup.sh y el mismo comando lunch que ya usaste. Luego, haz lo siguiente:

Crea una instancia local de Acloud con:

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

Acepta actualizaciones de paquetes obligatorios.
Si se te solicita, reinicia tu estación de trabajo para que se apliquen todos los cambios.
Selecciona el dispositivo Cuttlefish.

Deberías ver una sesión de VNC que contenga un dispositivo Android.

Puedes usar el mouse y el teclado para interactuar con el dispositivo virtual en tu estación de trabajo. También puedes seguir la actividad dentro de los registros mientras usas el dispositivo con el comando logcat de Android Debug Bridge (adb):

adb logcat

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 mediante el siguiente comando:
```
repo start <some-name> .
```
Edita SurfaceFlinger.cpp a fin de incluir las actualizaciones de la lista de cambios que se encuentra en la siguiente ubicación:
```
aosp/frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp
```
Busca las siguientes dos líneas:
```
postFrame();
postComposition();
```

Reemplázalas 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();

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

Actualiza la compilación en el dispositivo:

adb root
adb remount
adb sync
adb reboot
acloud reconnect

Si se te solicita que selecciones un dispositivo, elige el que muestre el tiempo transcurrido más corto (probablemente, el último de la lista). Para ver todas las instancias de dispositivos virtuales, utiliza los comandos acloud list y acloud list -v.

Verifica que se muestre un cambio de color en el dispositivo seleccionado, de forma similar a cómo se ve en la figura 1.

Ejemplo de un cambio de color exitoso

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

Cómo probar el código

Esta parte del codelab utiliza una prueba de ejemplo que se encuentra en el árbol de fuentes y que presenta errores. Utiliza Atest para ejecutar la prueba de forma local y probar el código.

Si deseas usar la prueba, sigue estas instrucciones:

Ejecuta:
```
atest DevCodelabTest
```
La prueba presentará un error. Para solucionarlo, busca el código fuente de la prueba que falló:
```
atest --info android.test.example.devcodelab.DevCodelabTest#testHelloWorld
```

Luego, mira aquí

platform_testing/tests/example/devcodelab

A fin de obtener el archivo que se editará, toma el nombre de la prueba en android.test.example.devcodelab.DevCodelabTest y reemplaza el . con la / 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)

Vuelve a ejecutar la prueba a los efectos de verificar que se haya corregido el problema:
```
atest DevCodelabTest
```

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

El repositorio simplifica el uso de Git. Para ello, agrupa comandos como git clone a fin de aplicarlos en varios repositorios (o proyectos) de Git al mismo tiempo.

Consulta las Herramientas de control de código fuente a los efectos de obtener descripciones generales de Git y Repo con vínculos a la documentación completa para trabajar con el código fuente de Android. Consulta en el repositorio de AOSP la lista completa de proyectos de Git y los individuales (rutas de acceso) para ramas asociadas con cada proyecto.

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

Cómo ver el cambio en Gerrit

Ve al vínculo impreso en la terminal que se parece a este:

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

De esta manera finaliza el codelab para principiantes sobre desarrollo para la plataforma de Android. Consulta Cómo enviar parches para conocer los próximos pasos y, a fin de obtener toda la información sobre el desarrollo de Android, explora el resto de este sitio.

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 lista de cambios. Para ello, haz clic en Abandon, en Gerrit.

Luego, abandona la rama temporal asociada del directorio frameworks/native del proyecto (o sus subdirectorios):

repo abandon codelab .

Además, recuerda revertir los cambios que realizaste en el archivo de prueba. Como no aplicaste las acciones de repo start, git commit ni repo upload para el cambio, puedes restablecer el archivo en sí. Si estás en el aosp/platform_testing directory, usa lo siguiente a fin de restablecer el archivo:

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

En este punto, habrás terminado. ¡Buen trabajo!

Obtén ayuda

Si encuentras errores durante este codelab, infórmalos mediante el 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.