À partir du 27 mars 2025, nous vous recommandons d'utiliser android-latest-release au lieu de aosp-main pour créer et contribuer à AOSP. Pour en savoir plus, consultez la section Modifications apportées à AOSP.

Cette page a été traduite par l'API Cloud Translation.

Essayer le développement Android
Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Ce tutoriel vous permet de tester le développement du système d'exploitation Android pour la première fois.

Configurer pour le développement Android

Avant de télécharger et de créer la branche de fichier manifeste android-latest-release de la source Android, assurez-vous que votre matériel répond aux exigences requises et que le logiciel requis est correctement installé. Vous devez également connaître les termes suivants:

Git: Git est un système de contrôle des versions distribué, Open Source et sans frais. Android utilise Git pour les opérations locales telles que la création de branches, les commits, les différences et les modifications. Pour en savoir plus sur Git, consultez la documentation Git.
Dépôt: Repo est un wrapper Python autour de Git qui simplifie l'exécution d'opérations complexes sur plusieurs dépôts Git. Repo ne remplace pas Git pour toutes les opérations de contrôle des versions. Il ne facilite que les opérations Git complexes. Le dépôt utilise des fichiers manifestes pour agréger les projets Git dans le superprojet Android.
fichier manifeste: Un fichier manifeste est un fichier XML qui spécifie l'emplacement des différents projets Git dans la source Android dans un arbre de sources AOSP.

Disposer de la configuration matérielle requise

Votre poste de travail de développement doit répondre aux exigences matérielles suivantes ou les dépasser:

Un système x86 64 bits.

Remarque :Vous pouvez compiler des versions AOSP antérieures à la version 2.3.x sur des systèmes 32 bits.
Au moins 400 Go d'espace disque disponible pour le check-out et la compilation du code (250 Go pour le check-out et 150 Go pour la compilation).

Remarque :Si vous effectuez un "checkout" d'un miroir, vous avez besoin de plus d'espace, car les miroirs complets du projet Android Open Source Project (AOSP) contiennent tous les dépôts Git qui ont déjà été utilisés.
Au moins 64 Go de RAM Google utilise des machines à 72 cœurs avec 64 Go de RAM pour compiler Android. Avec cette configuration matérielle, la compilation complète d'Android prend environ 40 minutes et la compilation incrémentielle d'Android ne prend que quelques minutes. En revanche, une compilation complète avec une machine à 6 cœurs et 64 Go de RAM prend environ six heures.

Respecter les exigences du système d'exploitation

Votre poste de travail de développement doit exécuter une distribution Linux 64 bits avec GNU C Library (glibc) 2.17 ou version ultérieure.

Installer les packages requis

Pour installer les paquets requis pour Ubuntu 18.04 ou version ultérieure, exécutez la commande suivante:

sudo apt-get install git-core gnupg flex bison build-essential zip curl zlib1g-dev libc6-dev-i386 x11proto-core-dev libx11-dev lib32z1-dev libgl1-mesa-dev libxml2-utils xsltproc unzip fontconfig

Installer le logiciel requis

Avant de pouvoir travailler avec AOSP, vous devez installer OpenJDK, Make, Python 3 et Repo. La dernière branche de version d'Android est fournie avec des versions précompilées d'OpenJDK, de Make et de Python 3. Aucune étape d'installation supplémentaire n'est donc requise. La section suivante explique comment installer Repo.

Installer le dépôt

Pour installer Repo, procédez comme suit:

Téléchargez les informations sur le package actuel:
```
sudo apt-get update
```
Exécutez la commande suivante pour installer le lanceur de dépôts:
```
sudo apt-get install repo
```
Le lanceur Repo fournit un script Python qui initialise un "checkout" et télécharge l'outil Repo complet.

Si vous y parvenez, passez à l'étape 4.
(Facultatif) Installez manuellement Repo à l'aide de la série de commandes suivante:
```
export REPO=$(mktemp /tmp/repo.XXXXXXXXX)
curl -o ${REPO} https://storage.googleapis.com/git-repo-downloads/repo
gpg --recv-keys 8BB9AD793E8E6153AF0F9A4416530D5E920F5C65
curl -s https://storage.googleapis.com/git-repo-downloads/repo.asc | gpg --verify - ${REPO} && install -m 755 ${REPO} ~/bin/repo
```
Les trois premières commandes configurent un fichier temporaire, téléchargent Repo dans le fichier et vérifient que la clé fournie correspond à la clé requise. Si ces commandes aboutissent, la commande finale installe le lanceur Repo.
Vérifiez la version du lanceur Repo:
```
repo version
```
Le résultat doit indiquer une version 2.4 ou ultérieure, par exemple:

repo launcher version 2.45

Télécharger la source Android

Le code source Android se trouve dans une collection de dépôts Git hébergés par Google. Chaque dépôt Git inclut l'intégralité de l'historique de la source Android, y compris les modifications apportées à la source et la date à laquelle elles ont été effectuées. Pour télécharger le code source Android:

Accédez à votre répertoire d'accueil:
```
cd ~
```
Créez un sous-répertoire de travail local dans celui-ci:
```
mkdir aosp
```
Accédez au répertoire:
```
cd aosp
```

Initialisez la dernière branche de version du code source du dépôt AOSP (android-latest-release):

repo init --partial-clone -b android-latest-release -u https://android.googlesource.com/platform/manifest

Saisissez ou acceptez vos identifiants Git (nom, adresse e-mail).
Synchronisez le code source:
```
repo sync -c -j8
```
Si vous rencontrez des problèmes lors du téléchargement, consultez Résoudre les problèmes de synchronisation.

Compiler le code

Pour compiler le code:

Dans votre répertoire de travail, sourcez le script envsetup.sh pour configurer votre environnement de compilation:
```
source build/envsetup.sh
```

Spécifiez un type d'appareil cible à compiler avec la commande lunch. Une cible est une permutation d'appareil, comme un modèle ou un facteur de forme spécifique. Spécifiez cette cible:

lunch aosp_cf_x86_64_only_phone-aosp_current-userdebug

Un résumé de votre environnement cible et de votre environnement de compilation devrait s'afficher:

============================================
PLATFORM_VERSION_CODENAME=Baklava
PLATFORM_VERSION=Baklava
TARGET_PRODUCT=aosp_cf_x86_64_only_phone
TARGET_BUILD_VARIANT=userdebug
TARGET_ARCH=x86_64
TARGET_ARCH_VARIANT=silvermont
HOST_OS=linux
HOST_OS_EXTRA=Linux-6.10.11-1rodete2-amd64-x86_64-Debian-GNU/Linux-rodete
HOST_CROSS_OS=windows
BUILD_ID=BP1A.250305.020
OUT_DIR=out
============================================

Créez la cible:
```
m
```

La première compilation peut prendre plusieurs heures. Les builds suivants prennent beaucoup moins de temps. Le résultat de votre compilation s'affiche dans $OUT_DIR.

Lancer Cuttlefish

Cuttlefish est l'émulateur Android utilisé pour tester vos builds.

Exécutez les commandes suivantes pour télécharger, compiler et installer les paquets Debian hôtes:

sudo apt install -y git devscripts equivs config-package-dev debhelper-compat golang curl
git clone https://github.com/google/android-cuttlefish
cd android-cuttlefish
for dir in base frontend; do
pushd $dir
# Install build dependencies
sudo mk-build-deps -i
dpkg-buildpackage -uc -us
popd
done
sudo dpkg -i ./cuttlefish-base_*_*64.deb || sudo apt-get install -f
sudo dpkg -i ./cuttlefish-user_*_*64.deb || sudo apt-get install -f
sudo usermod -aG kvm,cvdnetwork,render $USER
sudo reboot

Le redémarrage déclenche l'installation de modules de kernel supplémentaires et applique des règles udev.

Lancez Cuttlefish:
```
launch_cvd --daemon
```
Connectez-vous à l'appareil Cuttlefish en accédant à https://localhost:8443 dans votre navigateur Web. Votre appareil virtuel Android s'affiche.

Effectuer une modification

Mettez à jour le code source en suivant cet exemple de liste de modifications.

À partir de la racine de votre extraction (répertoire aosp/), accédez au projet Git frameworks/native:
```
cd frameworks/native
```
Démarrez un projet temporaire à l'aide de la commande suivante:
```
repo start <some-name> .
```
Utilisez votre éditeur pour modifier SurfaceFlinger.cpp à l'emplacement suivant:
```
aosp/frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp
```

Recherchez la ligne suivante:

void SurfaceFlinger::updateColorMatrixLocked() {

Ajoutez cette ligne au début de updateColorMatrixLocked():

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});

Créez le code:
```
m
```

Mettez à jour le build sur l'appareil:

adb root
adb remount -R
adb root
adb sync
adb reboot

Vérifiez que la couleur de l'appareil sélectionné change, comme illustré à la figure 1.

Figure 1 : Apparence de l'écran après un changement de couleur réussi

Corriger un test

Cette partie de l'atelier de programmation utilise un exemple de test qui se trouve dans l'arborescence source et qui échoue.

Pour exécuter, déboguer et corriger le test, procédez comme suit:

Exécutez:
```
atest DevCodelabTest
```
Le test échoue.

Remarque :atest est un outil de ligne de commande qui vous permet de créer, d'installer et d'exécuter des tests Android en local.

Examinez la trace de la pile du test défaillant:

STACKTRACE:
java.lang.AssertionError
 at org.junit.Assert.fail(Assert.java:87)
 at org.junit.Assert.assertTrue(Assert.java:42)
 at org.junit.Assert.assertTrue(Assert.java:53)
 at android.test.example.devcodelab.DevCodelabTest.testHelloWorld(DevCodelabTest.java:29)

La dernière ligne de la trace de la pile indique le test qui échoue (testHelloWorld). Ce test se trouve dans un fichier appelé DevCodelabTest.java.

Pour déterminer l'emplacement du test à corriger, ajoutez WORKING_DIRECTORY/platform_testing/tests/example/devcodelab/src/ à la dernière ligne de la trace de la pile jusqu'au nom du fichier de test, y compris. Ainsi, android.test.example.devcodelab.DevCodelabTest devient WORKING_DIRECTORY/platform_testing/tests/example/devcodelab/src/android/test/example/devcodelab/DevCodelabTest.java.
Modifiez platform_testing/tests/example/devcodelab/src/android/test/example/devcodelab/DevCodelabTest.java et remplacez Assert.assertTrue(false) par Assert.assertTrue(true).
Exécutez à nouveau le test pour vérifier que le problème est résolu:
```
atest DevCodelabTest
```

Importer votre code pour examen

Repo simplifie l'utilisation de Git en regroupant des commandes telles que git clone pour travailler sur plusieurs dépôts (ou projets) Git à la fois.

Pour examiner le code de vos projets dans Git, utilisez le système d'examen du code basé sur le Web Gerrit.

En supposant que vous ayez apporté vos modifications dans le projet frameworks/native, exécutez ces commandes pour importer vos modifications:
```
cd frameworks/native
repo start codelab .
git add .
git commit
```
Pour le message de votre commit, saisissez ce qui suit:
```
Android codelab change
Test: manual atest
```

Importez votre modification:

repo upload

Si l'opération réussit, un message semblable à celui-ci s'affiche:

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

Afficher votre modification dans Gerrit

Pour afficher votre modification dans Gerrit, accédez à la sortie du lien dans le terminal. Le lien ressemble à ceci:

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

Annuler votre modification

Normalement, après les tests, et après examen et approbation, vous envoyez votre modification dans Gerrit et la fusionnez dans le dépôt. À la place, pour les besoins de cet atelier de programmation, annulez votre travail:

Dans Gerrit, cliquez sur Abandon.
Abandonnez la branche temporaire associée dans le répertoire de projet frameworks/native (ou ses sous-répertoires):
```
repo abandon codelab .
```
Annulez les modifications que vous avez apportées au fichier de test. Comme vous n'avez pas exécuté repo start, git commit et repo upload pour le changement de test, vous pouvez réinitialiser le fichier lui-même. En supposant que vous vous trouviez dans aosp/platform_testing directory, utilisez la commande suivante pour réinitialiser le fichier:
```
git reset HEAD tests/example/devcodelab/src/android/test/example/devcodelab/DevCodelabTest.java
git checkout .
```

L'atelier de programmation sur le développement de la plate-forme Android est maintenant terminé.

Obtenir de l'aide

Si vous rencontrez des erreurs au cours de cet atelier de programmation, signalez-les à l'aide du lien Issue Tracker (Outil de suivi des problèmes) en bas de n'importe quelle page. Envoyez vos questions au groupe android-building.

Saisissez ps -A | grep crosvm pour voir si crosvm est déjà en cours d'exécution. Si crossvm est en cours d'exécution, saisissez le processus stop_cvd || true ou kill crosvm avec le PID du processus.