Comment compiler la ROM /e/OS ?

Catégories de builds

Choisissez la catégorie qui correspond aux modifications que vous comptez apporter et à la manière dont vous prévoyez de distribuer le résultat.

Les sources des builds community et official doivent être hébergées sur l’instance GitLab du projet ou sur une autre source publique de confiance, comme LineageOS ou AOSP. Consultez Types de versions pour les canaux de diffusion et les niveaux de support.

Comment compiler la ROM

Installer Docker

Si ce n’est pas déjà fait, installez Docker.

Récupérer l’image Docker

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

Trouver le code de votre appareil

Le code de l’appareil se trouve sur la liste des appareils /e/OS ou en exécutant la commande suivante avec ADB :

adb shell getprop ro.product.device

Choisir un répertoire de travail

Choisissez un système de fichiers sensible à la casse disposant d’au moins 400 Go d’espace libre. Faites pointer WORK_DIR vers un emplacement sur ce système de fichiers ; tous les fichiers sources, artefacts de build, journaux et données de cache du compilateur y seront stockés.

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

Optionnel : extraire les blobs propriétaires

Passez cette section pour un build community Docker habituel. Le builder utilise les manifestes publics et, par défaut, inclut les fichiers vendor propriétaires pris en charge provenant des manifestes publics TheMuppets.

N’utilisez cette étape optionnelle que lorsque les manifestes publics ne fournissent pas les fichiers vendor requis par votre appareil cible, ou lorsque le device tree que vous compilez attend des blobs extraits localement.

Pour extraire les blobs depuis un appareil connecté :

• Connectez l’appareil à votre ordinateur en USB.
• Activez ADB et le root.
• Rendez-vous dans ${WORK_DIR}/src/<branch>/device/<vendorname>/<my-device>.
• Exécutez le script d’extraction du device tree :

./extract-files.sh

Les blobs sont habituellement copiés dans ${WORK_DIR}/src/<branch>/vendor/<vendorname>/<my-device>. Une fois qu’ils sont en place, lancez le build Docker.

Lancer le build

Exécutez la commande suivante. N’oubliez pas de remplacer <my-device> par le code de votre appareil et <branch> par une branche de développement publique existante.

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=<branch>" \
-e "DEVICE_LIST=<my-device>" \
-e "REPO=https://gitlab.e.foundation/e/os/android.git" \
registry.gitlab.e.foundation:5000/e/os/docker-lineage-cicd:community

Choisissez une branche du dépôt public e/os/android.

Variables d’environnement

Transmettez les réglages de build à docker run avec -e "NAME=value". Seuls BRANCH_NAME et DEVICE_LIST doivent être définis pour un build standard d’appareil.

L’ensemble complet des options et leurs valeurs par défaut actuelles est défini dans Dockerfile.community.

Exemple pour le Fairphone 3/3+ avec la branche publique /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 convient à une grappe de disques durs. La valeur par défaut est 10 ; utilisez la valeur par défaut ou une valeur plus élevée sur un stockage SSD rapide si la connexion réseau peut suivre.

Pour une image émulateur x86_64 Android 16, utilisez le produit émulateur et activez l’empaquetage émulateur :

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

Le fichier IMG-e-…-sdk_phone_x86_64.zip obtenu est une archive d’image système Android SDK, et non un paquet de flash d’usine pour un appareil physique.

Android 16 contient actuellement un pointeur Git LFS public AOSP cassé dans une archive de données de test Rust. Le builder community l’enregistre comme un avertissement et continue, car ce fichier n’est pas nécessaire à l’image système. Définissez LFS_STRICT=true si tous les objets LFS doivent être disponibles dans votre environnement.

Mesures de référence d’un build FP3

Ces mesures sont un exemple, pas un minimum ni une garantie de performance. Elles ont été relevées pour un build FP3 Android 15 sur un Intel Core i9-9900K (8 cœurs, 16 threads), 62,7 Gio de RAM et une grappe RAID 1 composée de deux disques durs SATA :

Le build a utilisé jusqu’à environ 15 cœurs CPU logiques et 29,4 Gio de RAM. La récupération initiale a transféré environ 43,9 Go et écrit environ 336 Go sur le stockage. Les mesures de récupération incluent des reprises et ne constituent donc pas un benchmark contrôlé à cache froid.

Mesures de référence d’un build émulateur Android 16

La même machine hôte à disques durs a produit une image Android 16 sdk_phone_x86_64 avec BUILD_JOBS=18, sans cache de compilation, avec les temps suivants :

L’archive obtenue pesait 1,60 Go. Sa somme de contrôle et l’intégrité du ZIP ont été vérifiées, et elle contenait les métadonnées SDK x86_64 API 36, kernel-ranchu, ramdisk.img, system.img et vendor.img. Ces mesures incluent un build sans cache sur un stockage lent et ne constituent pas des garanties de performance.

Options de build

Vous pouvez désormais personnaliser les applications installées par défaut dans /e/OS.

• si vous voulez ajouter des applications supplémentaires aux applications par défaut : ajoutez votre APK dans le répertoire android_prebuilts_prebuiltapks/ et définissez la variable d’environnement CUSTOM_APPS en conséquence dans l’image Docker, avant de compiler.
• si vous voulez conserver un build /e/OS minimal, définissez la variable d’environnement MINIMAL_APPS à true (false par défaut). Pour l’instant, cela retire la visionneuse LibreOffice, PDFViewer, Cartes et Météo.

Récupérer votre image

Une fois le build terminé, retrouvez les paquets et leurs fichiers .sha256sum dans ${WORK_DIR}/zips/<my-device> :

• Avec BACKUP_IMG=true, IMG-e-…-<my-device>.zip est le paquet fastboot d’usine pour installer sur un appareil à partir de zéro. Il comprend les images de partitions, le script de flash et les binaires fastboot lorsque l’appareil fournit une configuration de flash d’usine.
• e-…-<my-device>.zip est le paquet OTA pour une mise à jour ou une installation via le recovery.
• Avec IS_EMULATOR=true, IMG-e-…-sdk_phone_x86_64.zip est une archive d’image système Android SDK pour créer un appareil virtuel d’émulation.

Vérifiez la somme de contrôle avant de flasher un paquet appareil ou d’installer une image système d’émulateur. Pour les étapes d’installation propres à chaque appareil, consultez la liste des appareils /e/OS.

Besoin d’aide supplémentaire

Si vous avez besoin d’aide, rapprochez-vous des autres compilateurs de ROM actifs sur notre forum qui compilent des ROM /e/OS non officielles. Une recherche sur internet de guides de compilation de ROM Android fera aussi apparaître des sites qui devraient vous être utiles.

Pour plus d’informations sur notre image docker et ses variables d’environnement, cliquez ici.

Pour signaler un problème concernant un build, consultez ce guide