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

Atelier de programmation pour développeurs Android

Vous pouvez contribuer au développement du système d’exploitation le plus largement installé dans l’histoire de la Terre. Oui, vous êtes ici pour vous lancer dans l'aventure 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 chaque jour grâce à un travail direct dans le projet Android Open Source (AOSP).

Alors asseyez-vous, lancez un terminal et écrivons l'histoire.

Objectifs

La mission de ce codelab est double :

Pour vous donner un petit aperçu de ce qu'est le flux de travail des développeurs pour les ingénieurs Android travaillant sur la plateforme (le système d'exploitation).
Nous vous encourageons à fournir des commentaires sur les outils, la documentation et le flux de travail des développeurs Android.

Conditions préalables

La liste des exigences pour cet atelier de programmation est dérivée de celles du développement de plates-formes générales ( AOSP ). Pour suivre cet atelier de programmation, configurez les éléments suivants :

Poste de travail Linux physique répondant à toutes les exigences publiques .
Repo et configuration Git requis pour modifier la base de code Android.

Environnement

En règle générale, les utilisateurs créent et développent directement sur le poste de travail. Étant donné que vous travaillez peut-être dans différents terminaux et que la plupart des commandes utilisées sont spécifiques au terminal, vous devrez les réexécuter à chaque session de terminal. Plus précisément, celles-ci incluent les commandes source build/envsetup.sh et lunch .

Configurer le poste de travail

Installez les packages nécessaires sur votre poste de travail.
Alors que vous êtes toujours dans un terminal, installez Repo et obtenez les informations d'identification pour tous les référentiels Git.

Initialiser et synchroniser le code

Accédez à votre répertoire personnel :
```
cd ~
```
Créez un sous-répertoire de travail local à l'intérieur :
```
mkdir aosp
```
Accédez au répertoire :
```
cd aosp
```
Initialisez la branche principale du code source du référentiel 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 synchronisations initiales peuvent prendre une heure ou plus.

Chaque extraction de dépôt est représentée par un fichier manifeste . Il est permis d'avoir plus d'une extraction de dépôt à la fois, à condition qu'elles existent dans des répertoires distincts. Mais notez que chaque extraction et construction équivaut à environ 300 Go d'utilisation (et en croissance), alors limitez-vous à 2 extractions de dépôt ou augmentez votre système avec un lecteur secondaire.

CONSEIL : Pour augmenter l'espace libre, supprimez un répertoire de branche et recommencez à partir de la création du répertoire, comme ceci : rm -rf aosp2.

Construire le code

Pour créer Android, vous devez sélectionner un type de périphérique cible à créer avec la commande lunch . Une cible est une permutation de périphérique, telle qu'un modèle ou un facteur de forme spécifique.

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

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

Configurez votre environnement pour créer des appareils Android en exécutant la commande suivante à partir de la racine de votre extraction de code source :
```
source build/envsetup.sh
```
Transmettez la cible de build à la commande lunch, comme ceci :
```
lunch aosp_cf_x86_64_phone-trunk_staging-userdebug
```
Créez le code depuis n'importe où dans votre paiement avec :
```
m
```

Attendez-vous à ce que la première construction prenne des heures. Les versions ultérieures prennent beaucoup moins de temps.

Lancer la seiche

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

Si vous n'avez jamais installé Cuttlefish, vous devez installer les dépendances Cuttlefish nécessaires. Dans une fenêtre de terminal, exécutez les commandes suivantes pour télécharger, créer 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 .

Lancement de la seiche :
```
launch_cvd --daemon</code>
```
Connectez-vous à l'appareil Cuttlefish en accédant à https://localhost:8443 dans votre navigateur Web. Vous êtes accueilli avec un flux vidéo de l'appareil Android que vous venez de construire.

Faire un changement

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

À partir de la racine de votre paiement (répertoire aosp/ ), accédez au projet frameworks/native Git :
```
cd frameworks/native
```
Démarrez un projet temporaire avec cette commande :
```
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
```
Trouvez cette ligne :
```
postComposition();
```

Remplacez ces deux lignes par ce qui suit :

postComposition();
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});
updateColorMatrixLocked();

Construisez le code :
```
m
```

Mettez à jour la version sur l'appareil :

adb root
adb remount
adb sync
adb reboot

Vérifiez que vous voyez un changement de couleur sur votre appareil sélectionné similaire à celui illustré dans la figure 1.

Example of a successful color change

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

Testez 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 localement et tester le code.

Pour utiliser le test, suivez ces instructions :

Courir:
```
atest DevCodelabTest
```
Le test échouera. Pour résoudre ce problème, recherchez le code source du test ayant échoué :
```
atest --info android.test.example.devcodelab.DevCodelabTest#testHelloWorld
```

Alors regarde ici

platform_testing/tests/example/devcodelab

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

Puis éditez

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

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
```

Téléchargez votre code pour examen

Repo simplifie l'utilisation de Git en regroupant des commandes telles que git clone pour fonctionner simultanément sur plusieurs référentiels (ou projets) Git.

Voir Outils de contrôle de code source pour une présentation de Git et Repo, avec des liens vers une documentation complète sur l'utilisation du code source Android. Consultez le référentiel AOSP pour la liste complète des projets Git et les projets individuels (chemins) pour les branches associées à chaque projet.

Pour la révision du code de vos projets dans Git, vous utiliserez le système de révision de code basé sur le Web Gerrit .

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

Si vous réussissez, vous voyez un message ressemblant à celui-ci :

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 changement dans Gerrit

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

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

Ceci termine l’atelier de programmation de démarrage pour le développement de la plate-forme Android. Consultez Soumission de correctifs pour connaître les étapes suivantes et pour plus de détails sur le développement d’Android, consultez le reste de ce site.

Annulez votre modification

Normalement, après les tests et après examen et approbation, vous soumettez votre modification dans Gerrit et la fusionnez dans le référentiel.

Au lieu de cela, pour les besoins de cet atelier de programmation, annulez votre liste de modifications en cliquant sur Abandonner dans Gerrit.

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

repo abandon codelab .

N'oubliez pas également d'annuler les modifications que vous avez apportées au fichier de test. Puisque vous n'avez pas repo start , git commit et repo upload la modification, vous pouvez réinitialiser le fichier lui-même. En supposant que vous vous trouviez dans le aosp/platform_testing directory , utilisez ce qui suit 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é ! Bon travail!

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é au bas de n'importe quelle page. Envoyez des questions au groupe de construction Android .