Questa pagina è stata tradotta dall'API Cloud Translation.

Codelab per sviluppatori Android

Puoi aiutare a sviluppare il sistema operativo più installato nella storia della Terra. Sì, sei qui per intraprendere il viaggio per diventare un ingegnere di piattaforme Android.

Sebbene il percorso sia impegnativo, il team di Android si impegna a semplificare il tuo viaggio, a ogni uscita. E il team apporta miglioramenti ogni giorno attraverso il lavoro diretto nell'Android Open Source Project (AOSP).

Quindi siediti, accendi un terminale e facciamo la storia.

Obiettivi

La missione di questo codelab è duplice:

Per darti un piccolo assaggio di com'è il flusso di lavoro dello sviluppatore per gli ingegneri Android che lavorano sulla piattaforma (il sistema operativo).
Ti incoraggiamo a fornire feedback sugli strumenti, la documentazione e il flusso di lavoro degli sviluppatori di Android.

Prerequisiti

L'elenco dei requisiti per questo codelab deriva da quelli per lo sviluppo della piattaforma generale ( AOSP ). Per prendere questo codelab, imposta quanto segue:

Workstation Linux fisica che soddisfa tutti i requisiti pubblici .
Repo e la configurazione Git necessaria per modificare la base di codice Android.

Ambiente

In genere, gli utenti creano e sviluppano direttamente sulla workstation. Poiché potresti lavorare in vari terminali e molti dei comandi utilizzati sono specifici del terminale, dovrai eseguirli nuovamente in ogni sessione di terminale. Nello specifico, questi includono i comandi source build/envsetup.sh e lunch .

Installa la postazione di lavoro

Installa i pacchetti necessari sulla tua workstation.
Mentre sei ancora in un terminale, installa Repo e ottieni le credenziali per tutti i repository Git.

Inizializza e sincronizza il codice

Naviga nella tua home directory:
```
cd ~
```
Crea una sottodirectory di lavoro locale al suo interno:
```
mkdir aosp
```
Naviga nella directory:
```
cd aosp
```
Inizializza il ramo principale del codice sorgente del repository AOSP (impostazione predefinita):
```
repo init -u https://android.googlesource.com/platform/manifest
```
Inserisci o accetta le tue credenziali Git (nome, indirizzo email).
Sincronizza il codice sorgente:
```
repo sync -j8
```

Le sincronizzazioni iniziali possono richiedere un'ora o più.

Ogni checkout del repository è rappresentato da un file manifest . È consentito avere più di 1 checkout del repository alla volta, purché esistano in directory distinte. Ma tieni presente che ogni checkout e build ammonta a circa 300 GB di utilizzo (e in crescita), quindi limitati a 2 checkout del repository o aumenta il tuo sistema con un'unità secondaria.

SUGGERIMENTO: per aumentare lo spazio libero, eliminare una directory branch e ricominciare dalla creazione della directory, in questo modo: rm -rf aosp2.

Costruisci il codice

Per compilare Android, devi selezionare un tipo di dispositivo di destinazione da compilare con il comando lunch . Un obiettivo è una permutazione del dispositivo, come un modello specifico o un fattore di forma.

La destinazione del dispositivo inclusa di seguito, aosp_cf_x86_64_phone-userdebug , consente di creare il dispositivo Android virtuale Cuttlefish per i test senza un dispositivo fisico.

Per creare e aggiornare invece un dispositivo fisico, scegli un altro target e segui le istruzioni per il flashing dei dispositivi .

Configura il tuo ambiente per la creazione di dispositivi Android eseguendo il seguente comando dalla radice del checkout del codice sorgente:
```
source build/envsetup.sh
```
Passa il build target al comando lunch, in questo modo:
```
lunch aosp_cf_x86_64_phone-userdebug
```
Crea il codice da qualsiasi punto del tuo checkout con:
```
m
```

Aspettatevi che la prima build richieda ore. Le build successive richiedono molto meno tempo.

Crea un'istanza Acloud

Acloud è uno strumento da riga di comando in AOSP che assiste gli utenti nella creazione di dispositivi Android virtuali, in questo caso Cuttlefish.

Se ti trovi nella stessa sessione di terminale utilizzata per creare il codice , procedi. Altrimenti, esegui nuovamente lo script envsetup.sh e lo stesso comando lunch che hai usato prima. Poi

Crea un'istanza locale Acloud con:

acloud create --local-image --local-instance

Accetta gli aggiornamenti ai pacchetti richiesti.
Se richiesto, riavviare la workstation per rendere effettive tutte le modifiche.
Seleziona il dispositivo Seppia.

Dovresti essere accolto con una sessione VNC contenente un dispositivo Android!

Puoi interagire con il dispositivo virtuale sulla tua workstation utilizzando il mouse e la tastiera. Puoi anche seguire l'attività all'interno dei log mentre usi il tuo dispositivo utilizzando il comando logcat di Android Debug Bridge (adb):

adb logcat

Fare un cambiamento

Aggiorna il codice sorgente seguendo questo esempio changelist .

Dalla radice del tuo checkout ( aosp/ directory), vai al frameworks/native Git project:
```
cd frameworks/native
```
Avvia un progetto temporaneo con questo comando:
```
repo start <some-name> .
```
Modifica SurfaceFlinger.cpp per includere gli aggiornamenti dall'elenco delle modifiche nel seguente percorso:
```
aosp/frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp
```
Trova questa riga:
```
postComposition();
```

Sostituisci queste due righe con le seguenti:

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

Costruisci il codice:
```
m
```

Aggiorna la build sul dispositivo:

adb root
adb remount
adb sync
adb reboot
acloud reconnect

Se ti viene chiesto di selezionare un dispositivo, scegli quello che mostra il tempo trascorso più breve. (Questo è probabilmente l'ultimo nell'elenco che vedi.) Per vedere tutte le istanze del dispositivo virtuale, usa i comandi acloud list e acloud list -v .

Verifica di vedere un cambiamento di colore sul dispositivo selezionato simile a quanto mostrato nella Figura 1.

Example of a successful color change

Figura 1. Aspetto dello schermo dopo aver cambiato colore con successo

Metti alla prova il tuo codice

Questa parte del codelab utilizza un test di esempio che si trova nell'albero dei sorgenti e non riesce. Questo impiega Atest per eseguire il test localmente e testare il codice.

Per utilizzare il test, seguire queste istruzioni:

Correre:
```
atest DevCodelabTest
```

Il test fallirà. Per risolverlo, trova il codice sorgente del test fallito:

atest --info android.test.example.devcodelab.DevCodelabTest#testHelloWorld

Allora guarda qui

platform_testing/tests/example/devcodelab

Per ottenere il file da modificare, prendi il nome del test in android.test.example.devcodelab.DevCodelabTest e sostituisci il . con / , per ottenere questo risultato:
```
src/android/test/example/devcodelab/DevCodelabTest.java
```

Quindi modifica

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

Rimpiazzare

Assert.assertTrue(false)

con

Assert.assertTrue(true)

Esegui di nuovo il test per verificare di aver risolto il problema:
```
atest DevCodelabTest
```

Carica il tuo codice per la revisione

Repo semplifica l'utilizzo di Git raggruppando comandi come git clone per lavorare su numerosi repository Git (o progetti) contemporaneamente.

Vedere Strumenti di controllo del codice sorgente per panoramiche su Git e Repo, con collegamenti alla documentazione completa sull'utilizzo del codice sorgente Android. Consulta il repository AOSP per l'elenco completo dei progetti Git e i singoli progetti (percorsi) per i rami associati a ciascun progetto.

Per la revisione del codice dei tuoi progetti in Git, utilizzerai il sistema di revisione del codice basato sul Web Gerrit .

Supponendo che tu abbia apportato le modifiche nei frameworks/native , esegui questi comandi per caricarli:
```
cd frameworks/native
repo start codelab .
git add .
git commit
```
Per il tuo messaggio di commit, inserisci quanto segue:
```
Android codelab change
Test: manual atest
```
Carica la tua modifica:
```
repo upload
```

Se hai successo, vedrai un messaggio simile a questo:

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

Visualizza il tuo cambiamento in Gerrit

Vai al link, stampato nel terminale, che assomiglia a questo:

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

Questo completa il codelab iniziale per lo sviluppo della piattaforma Android. Vedere Invio di patch per i passaggi successivi e per i dettagli completi sullo sviluppo di Android, vedere il resto di questo sito.

Annulla la tua modifica

Normalmente, dopo il test e dopo la revisione e l'approvazione, invii la tua modifica in Gerrit e la unisci al repository.

Invece, ai fini di questo codelab, ripristina l'elenco delle modifiche facendo clic su Abbandona in Gerrit.

Quindi abbandonare il ramo temporaneo associato nella directory frameworks/native project (o nelle sue sottodirectory):

repo abandon codelab .

Ricorda anche di ripristinare le modifiche apportate al file di test. Poiché non hai repo start , git commit e repo upload la modifica, puoi reimpostare il file stesso. Supponendo di trovarti nella aosp/platform_testing directory , utilizza quanto segue per reimpostare il file:

git reset HEAD tests/example/devcodelab/src/android/test/example/devcodelab/DevCodelabTest.java
git checkout .

A questo punto, hai finito! Bel lavoro!

Ottenere aiuto

Se riscontri errori durante questo codelab, segnalali utilizzando il link Issue Tracker nella parte inferiore di qualsiasi pagina. Invia domande al gruppo di costruzione di Android .