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

Atelier de programmation pour les développeurs Android

Vous pouvez contribuer au développement du système d'exploitation le plus largement installé de l'histoire de la Terre. Oui, vous êtes ici pour vous lancer dans le parcours qui vous permettra de devenir ingénieur de plate-forme Android.

Bien que le chemin soit difficile, l'équipe Android s'efforce de simplifier votre parcours à chaque version. Et l'équipe apporte des améliorations tous les jours grâce à dans le projet Android Open Source (AOSP).

Asseyez-vous, allumez un terminal et entrez dans l'histoire.

Objectifs

Cet atelier de programmation a deux objectifs :

Pour vous donner un aperçu du workflow du développeur comme pour les ingénieurs Android travaillant sur la plateforme (le système d’exploitation).
Vous encouragent à nous envoyer vos commentaires sur les outils, la documentation et le workflow de développement Android.

Prérequis

La liste des conditions requises pour cet atelier de programmation est dérivée de celles du développement de la plate-forme générale (AOSP). Pour cet atelier de programmation, configurez les éléments suivants:

Poste de travail Linux physique répondant à toutes les exigences publiques.
Dépôt et configuration Git requis pour modifier le code de base Android.

Environnement

En règle générale, les utilisateurs effectuent le build et le développement directement sur la station de travail. Étant donné que vous pouvez travailler dans différents terminaux et que de nombreuses commandes utilisées sont spécifiques à un terminal, vous devrez les réexécuter dans chaque session de terminal. Plus précisément, dont les commandes source build/envsetup.sh et lunch.

Configurer une station de travail

Installez les packages nécessaires sur votre poste de travail.
Dans un terminal, installez Repo et obtenez des identifiants. dans tous les dépôts Git.

Initialiser et synchroniser le code

Accédez à votre répertoire d'accueil :
```
cd ~
```
Créez un sous-répertoire de travail local:
```
mkdir aosp
```
Accédez au répertoire :
```
cd aosp
```
Initialisez la branche principale du code source du dépôt AOSP (par défaut):
```
repo init -u https://android.googlesource.com/platform/manifest
```
Saisissez ou acceptez vos identifiants Git (nom, adresse e-mail).
Synchronisez le code source:
```
repo sync -j8
```

Les premières synchronisations peuvent prendre une heure ou plus.

Chaque paiement du dépôt est représenté par un fichier manifeste. Il est possible d'effectuer plusieurs règlements du dépôt à la fois, à condition qu'ils existent dans des répertoires distincts. Notez toutefois que chaque extraction et compilation représente environ 300 Go d'espace utilisé (et plus encore). Limitez-vous donc à deux extractions de dépôts ou ajoutez un disque secondaire à votre système.

ASTUCE : Pour libérer de l'espace, supprimez un répertoire de branche et recommencez à partir de la création de répertoire, comme suit : rm -rf aosp2.

Compiler le code

Pour compiler Android, vous devez sélectionner 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.

La cible d'appareil aosp_cf_x86_64_phone-userdebug vous permet de créer l'appareil Android virtuel Cuttlefish pour les tests sans appareil physique.

Si vous préférez créer et mettre à jour un appareil physique, choisissez une autre cible et suivez les instructions pour flasher les périphériques.

Configurez votre environnement pour créer des appareils Android en exécutant la à partir de la racine de l'extraction de votre code source:
```
source build/envsetup.sh
```
Transmettez la cible de compilation à la commande "déjeuner", comme ceci:
```
lunch aosp_cf_x86_64_phone-trunk_staging-userdebug
```
Compilez le code où que vous soyez dans votre paiement avec:
```
m
```

La première compilation peut prendre plusieurs heures. Les compilations suivantes prennent beaucoup moins de temps.

Lancer seiche

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

Si vous n'avez jamais installé Cuttlefish, vous devez installer les Dépendances de seiches. Dans une fenêtre de terminal, 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. Un flux vidéo de l'appareil Android que vous venez de créer 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> .
```
Modifiez SurfaceFlinger.cpp pour inclure les mises à jour de la liste de modifications à l'emplacement suivant :
```
aosp/frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp
```

Recherchez la ligne suivante :

void SurfaceFlinger::updateColorMatrixLocked() {

Ajoutez ces deux lignes 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});

Compilez le code:
```
m
```

Mettez à jour le build sur l'appareil :

adb root
adb remount
adb sync
adb reboot

Vérifiez que vous constatez sur l'appareil sélectionné un changement de couleur semblable à celui qui s'affiche comme indiqué dans la figure 1.

Exemple de changement de couleur réussi

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

Tester votre code

Cette partie de l'atelier de programmation utilise un exemple de test qui se trouve dans l'arborescence source et qui échoue. Cela utilise Atest pour exécuter le test en local et tester le code.

Pour utiliser le test, procédez comme suit:

Exécutez la commande suivante:
```
atest DevCodelabTest
```

Le test échouera. Examinez la trace de la pile du test qui échoue:

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)

Regardez ici

platform_testing/tests/example/devcodelab

Pour obtenir le fichier à modifier, prenez le nom du test dans android.test.example.devcodelab.DevCodelabTest et remplacez . par / pour obtenir ce résultat :
```
src/android/test/example/devcodelab/DevCodelabTest.java
```

Modifiez ensuite

platform_testing/tests/example/devcodelab/src/android/test/example/devcodelab/DevCodelabTest.java

pour remplacer

Assert.assertTrue(false)

par

Assert.assertTrue(true)

Exécutez à nouveau le test pour vérifier que vous avez résolu le problème :
```
atest DevCodelabTest
```

Importer votre code pour examen

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

Consultez la section Outils de contrôle des sources pour obtenir une présentation de Git et de Repo, avec des liens vers la documentation complète sur l'utilisation du code source Android. Consultez le dépôt AOSP pour obtenir la liste complète des projets Git et des projets individuels (chemins d'accès) des branches associées à chaque projet.

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

Si vous avez apporté vos modifications dans le projet frameworks/native, exécutez ces commandes pour les importer :
```
cd frameworks/native
repo start codelab .
git add .
git commit
```
Pour votre message de commit, saisissez la commande suivante:
```
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 main:
  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/main

Afficher votre modification dans Gerrit

Accédez au lien imprimé dans le terminal, qui ressemble à celui-ci :

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

Vous avez terminé l'atelier de programmation de démarrage pour le développement sur la plate-forme Android. Pour connaître les prochaines étapes, consultez Envoyer des correctifs. Pour en savoir plus sur le développement d'Android, consultez le reste de ce site.

Annuler la 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 liste de modifications en cliquant sur Abandon (Abandon) dans Gerrit.

Abandonnez ensuite la branche temporaire associée dans le répertoire de projet frameworks/native (ou ses sous-répertoires) :

repo abandon codelab .

N'oubliez pas non plus d'annuler les modifications apportées au fichier de test. Puisque vous n'avez pas repo start, git commit et repo upload, vous pouvez réinitialiser 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 .

Vous avez terminé ! Bravo !

Obtenir de l'aide

Si vous rencontrez des erreurs au cours de cet atelier de programmation, signalez-les à l'aide du Issue Tracker en bas de n'importe quelle page. Envoyez vos questions au construction-android groupe.