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)
Animarte a brindar comentarios sobre las herramientas, la documentación y el flujo de trabajo de desarrollo de Android cuando empiezas desde cero

Requisitos previos

A continuación, se muestra la lista completa de requisitos del codelab, que derivan de aquellos 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 -j16
```

Las sincronizaciones iniciales pueden tardar una hora o más. Consulta las instrucciones de descarga a fin de obtener información relacionada mientras esperas.

Cada proceso 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 estos 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 de modo 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
```
Agrega lo siguiente debajo de la línea de código que acabas de incluir:
```
updateColorMatrixLocked();
```
Compila el código:
```
m
```

Actualiza la compilación en el dispositivo:

adb root
adb remount
adb sync
adb reboot
acloud reconnect

Verifica que veas un cambio de color en el dispositivo.

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 . por / para obtener este resultado:
```
src/android/test/example/devcodelab/DevCodelabTest.java
```

Edita lo siguiente

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 a fin de conocer los próximos pasos y explora el resto de este sitio a los efectos de obtener toda la información para desarrollar para Android.

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.