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

Atelier de programmation pour les développeurs Android

Vous pouvez nous aider à développer le système d'exploitation le plus installé de l'histoire de la Terre. Oui, vous êtes là pour vous lancer dans l'aventure et devenir un ingénieur de plate-forme Android.

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

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

Objectifs

L'objectif de cet atelier de programmation est double:

Pour vous donner un aperçu du workflow de développement pour les ingénieurs Android travaillant sur la plate-forme (le système d'exploitation).
Nous vous encourageons à envoyer des commentaires sur les outils, la documentation et le workflow du développeur Android.

Conditions préalables

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

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

Environnement

En règle générale, les utilisateurs compilent et développent leurs applications directement sur la station de travail. Étant donné que vous travaillez peut-être 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, elles incluent 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 pour 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 suivant:
```
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 retraits de dépôts à la fois, à condition qu'ils se trouvent dans des répertoires distincts. Notez toutefois que chaque règlement et chaque build représentent une utilisation d'environ 300 Go (et ce qui augmente). Par conséquent, limitez-vous à deux paiements de dépôt ou étendez votre système avec un disque secondaire.

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

Compiler le code

Pour compiler Android, vous devez sélectionner un type d'appareil cible à compiler à l'aide de 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 effectuer des tests sans appareil physique.

Pour créer et mettre à jour un appareil physique, choisissez une autre cible et suivez les instructions pour flasher des appareils.

Configurez votre environnement pour compiler des appareils Android en exécutant la commande suivante à partir de la racine 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 depuis n'importe quel emplacement de la page de paiement avec la commande suivante:
```
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 nécessaires. Dans une fenêtre de terminal, exécutez les commandes suivantes pour télécharger, compiler et installer les packages 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 noyau supplémentaires et applique les règles udev.

Lancez Settlefish:
```
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 processus de paiement (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 cette ligne:

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 de 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 échoue. Atest est utilisé 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. Pour résoudre le problème, recherchez le code source du test ayant échoué:
```
atest --info android.test.example.devcodelab.DevCodelabTest#testHelloWorld
```

Regardez ici

platform_testing/tests/example/devcodelab

Pour modifier le fichier, prenez le nom du test dans android.test.example.devcodelab.DevCodelabTest et remplacez . par /. Vous obtiendrez le résultat suivant:
```
src/android/test/example/devcodelab/DevCodelabTest.java
```

Ensuite, modifiez

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

pour remplacer

Assert.assertTrue(false)

Avec

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 simultanément sur plusieurs dépôts (ou projets) Git.

Consultez la page Outils de contrôle source pour obtenir une présentation de Git et 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) pour les branches associées à chaque projet.

Pour les revues de code de vos projets dans Git, vous utiliserez le système Web de révision de code Gerrit.

En supposant que vous ayez effectué vos modifications dans le projet frameworks/native, exécutez les commandes suivantes 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 qui apparaît dans le terminal et qui ressemble à celui-ci:

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

L'atelier de programmation de démarrage sur le développement de la plate-forme Android est maintenant terminé. Consultez la section Envoyer des correctifs pour connaître les étapes suivantes. Pour obtenir des informations complètes 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.

Pour les besoins de cet atelier de programmation, annulez plutôt votre liste de modifications en cliquant sur Abandon (Abandonner) dans Gerrit.

Abandonnez ensuite la branche temporaire associée dans le répertoire du 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. Comme vous n'avez pas effectué les opérations repo start, git commit et repo upload, vous pouvez réinitialiser le fichier lui-même. En supposant que vous vous trouvez 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 .

À ce stade, vous avez terminé. Bien joué !

Obtenir de l'aide

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