¿Cómo compilar la ROM de /e/OS?

Categorías de compilación

Elige la categoría que coincida con los cambios que pretendes hacer y cómo piensas distribuir el resultado.

Las fuentes de las compilaciones community y official deben alojarse en la instancia de GitLab del proyecto u otra fuente pública de confianza, como LineageOS o AOSP. Ver Build Status para los canales de versiones y niveles de soporte.

Cómo compilar la ROM

Instalar Docker

Si aún no lo has hecho, instala Docker.

Obtener la imagen de Docker

docker pull registry.gitlab.e.foundation:5000/e/os/docker-lineage-cicd:community

Encontrar el código de tu dispositivo

El código del dispositivo puede encontrarse en la lista de dispositivos /e/OS o ejecutando el siguiente comando desde ADB:

adb shell getprop ro.product.device

Elegir un directorio de trabajo

Elige un sistema de archivos sensible a mayúsculas con al menos 400 GB de espacio libre. Fija WORK_DIR en una ubicación de ese sistema de archivos; todos los archivos fuente, artefactos de compilación, registros y datos de caché del compilador se almacenarán debajo de él.

export WORK_DIR=/path/to/eos-build
mkdir -p \
"${WORK_DIR}/src" \
"${WORK_DIR}/zips" \
"${WORK_DIR}/logs" \
"${WORK_DIR}/ccache"

Opcional: extraer blobs propietarios

Salta esta sección para la compilación community habitual con Docker. El constructor usa los manifiestos públicos y, por defecto, incluye los archivos propietarios de vendor soportados de los manifiestos públicos de TheMuppets.

Usa este paso opcional solo cuando los manifiestos públicos no proporcionen los archivos de vendor que necesita tu dispositivo de destino, o cuando el árbol de dispositivo que vas a compilar espere blobs extraídos localmente.

Para extraer blobs de un dispositivo conectado:

• Conecta el dispositivo a tu ordenador por USB.
• Activa ADB y root.
• Ve a ${WORK_DIR}/src/<rama>/device/<nombre-del-vendor>/<mi-dispositivo>.
• Ejecuta el script de extracción del árbol de dispositivo:

./extract-files.sh

Los blobs suelen copiarse a ${WORK_DIR}/src/<rama>/vendor/<nombre-del-vendor>/<mi-dispositivo>. Una vez en su sitio, ejecuta la compilación Docker.

Iniciar la compilación

Ejecuta el siguiente comando. No olvides reemplazar <mi-dispositivo> por el código de tu dispositivo y <rama> por una rama de desarrollo pública existente.

docker run --rm \
-v "${WORK_DIR}/src:/srv/src" \
-v "${WORK_DIR}/zips:/srv/zips" \
-v "${WORK_DIR}/logs:/srv/logs" \
-v "${WORK_DIR}/ccache:/srv/ccache" \
-e "BRANCH_NAME=<rama>" \
-e "DEVICE_LIST=<mi-dispositivo>" \
-e "REPO=https://gitlab.e.foundation/e/os/android.git" \
registry.gitlab.e.foundation:5000/e/os/docker-lineage-cicd:community

Elige una rama del repositorio público e/os/android.

Variables de entorno

Pasa los ajustes de compilación a docker run con -e "NOMBRE=valor". Solo BRANCH_NAME y DEVICE_LIST deben fijarse para una compilación estándar de dispositivo.

El conjunto completo de opciones y sus valores predeterminados actuales está definido en Dockerfile.community.

Ejemplo para Fairphone 3/3+ usando la rama pública /e/OS v4.2 Android 15:

docker run --rm \
-v "${WORK_DIR}/src:/srv/src" \
-v "${WORK_DIR}/zips:/srv/zips" \
-v "${WORK_DIR}/logs:/srv/logs" \
-v "${WORK_DIR}/ccache:/srv/ccache" \
-e "BRANCH_NAME=v4.2-a15" \
-e "DEVICE_LIST=FP3" \
-e "REPO=https://gitlab.e.foundation/e/os/android.git" \
-e "INCLUDE_PROPRIETARY=false" \
-e "BACKUP_IMG=true" \
-e "REPO_JOBS=2" \
registry.gitlab.e.foundation:5000/e/os/docker-lineage-cicd:community

REPO_JOBS=2 es adecuado para un array de discos duros. El valor predeterminado es 10; usa el predeterminado o un valor mayor en almacenamiento SSD rápido si la conexión de red puede seguir el ritmo.

Para una imagen de emulador Android 16 x86_64, usa el producto de emulador y activa el empaquetado de emulador:

docker run --rm \
-v "${WORK_DIR}/src:/srv/src" \
-v "${WORK_DIR}/zips:/srv/zips" \
-v "${WORK_DIR}/logs:/srv/logs" \
-v "${WORK_DIR}/ccache:/srv/ccache" \
-e "BRANCH_NAME=v4.2-a16" \
-e "DEVICE_LIST=sdk_phone_x86_64" \
-e "REPO=https://gitlab.e.foundation/e/os/android.git" \
-e "INCLUDE_PROPRIETARY=false" \
-e "IS_EMULATOR=true" \
registry.gitlab.e.foundation:5000/e/os/docker-lineage-cicd:community

El IMG-e-…-sdk_phone_x86_64.zip resultante es un archivo de imagen de sistema del SDK de Android, no un paquete de flasheo de fábrica para un dispositivo físico.

Android 16 contiene actualmente un puntero público de Git LFS roto en un archivo de datos de prueba de Rust. El constructor community lo registra como aviso y continúa, porque el archivo no es necesario para la imagen de sistema. Fija LFS_STRICT=true si cada objeto LFS debe estar disponible en tu entorno.

Medidas de referencia de la compilación FP3

Estas medidas son un ejemplo, no un mínimo ni una garantía de rendimiento. Se registraron para una compilación Android 15 de FP3 en un Intel Core i9-9900K (8 núcleos, 16 hilos), 62,7 GiB de RAM y un array RAID 1 de dos discos duros SATA:

La compilación usó hasta unos 15 núcleos lógicos de CPU y 29,4 GiB de RAM. La descarga inicial transfirió unos 43,9 GB y escribió unos 336 GB en el almacenamiento. Las medidas de la descarga incluyen reintentos y por tanto no son un benchmark controlado de caché fría.

Medidas de referencia de la compilación del emulador Android 16

El mismo host basado en HDD produjo una imagen Android 16 sdk_phone_x86_64 con BUILD_JOBS=18, sin caché de compilador y con los siguientes tiempos:

El archivo resultante pesó 1,60 GB. Se verificaron su suma de comprobación y su integridad ZIP, y contenía los metadatos del SDK x86_64 de la API 36, kernel-ranchu, ramdisk.img, system.img y vendor.img. Estas medidas incluyen una compilación sin caché en almacenamiento lento y no son garantías de rendimiento.

Opciones de compilación

Ya puedes personalizar las aplicaciones instaladas por defecto en /e/OS.

• si quieres añadir aplicaciones extra a las predeterminadas: añade tu APK al directorio android_prebuilts_prebuiltapks/, y fija la variable de entorno CUSTOM_APPS en consecuencia en la imagen de Docker, antes de compilar.
• si quieres mantener una compilación de /e/OS mínima, fija la variable de entorno MINIMAL_APPS a true (por defecto es false). Por ahora elimina el visor de LibreOffice, PDFViewer, Maps y Weather.

Obtener tu imagen

Cuando tu compilación termine, encontrarás los paquetes y sus archivos .sha256sum en ${WORK_DIR}/zips/<mi-dispositivo>:

• Con BACKUP_IMG=true, IMG-e-…-<mi-dispositivo>.zip es el paquete fastboot de fábrica para instalar en un dispositivo desde cero. Incluye las imágenes de las particiones, el script de flasheo y los binarios fastboot cuando el dispositivo proporciona una configuración de flasheo de fábrica.
• e-…-<mi-dispositivo>.zip es el paquete OTA para una actualización o una instalación basada en recovery.
• Con IS_EMULATOR=true, IMG-e-…-sdk_phone_x86_64.zip es un archivo de imagen de sistema del SDK de Android para crear un dispositivo virtual de emulador.

Verifica la suma de comprobación antes de flashear un paquete de dispositivo o instalar una imagen de sistema de emulador. Para los pasos de instalación específicos de cada dispositivo, consulta la lista de dispositivos /e/OS.

¿Necesitas más ayuda?

Si necesitas ayuda, consulta con otros constructores de ROM activos en nuestro foro que compilan ROM no oficiales de /e/OS. Una búsqueda en internet de guías sobre compilación de ROM de Android también mostrará sitios que pueden ser útiles.

Para más información sobre nuestra imagen de docker y sus variables de entorno, haz clic aquí.

Para informar de un problema sobre una compilación, consulta esta guía