Questa pagina è stata tradotta dall'API Cloud Translation.

Provare lo sviluppo Android

Questo tutorial ti consente di provare per la prima volta lo sviluppo del sistema operativo Android.

Configurazione per lo sviluppo Android

Prima di scaricare e compilare il ramo main del codice sorgente di Android, assicurati che l'hardware soddisfi i requisiti necessari e che il software richiesto sia installato correttamente. Dovresti inoltre conoscere i seguenti termini:

Git: Git è un sistema di controllo della versione distribuito, senza costi e open source. Android utilizza Git per le operazioni locali come la creazione di diramazioni, i commit, le differenze e le modifiche. Per informazioni sull'apprendimento di Git, consulta la documentazione di Git.
Repository: Repo è un wrapper Python per Git che semplifica l'esecuzione di operazioni complesse su più repository Git. Repo non sostituisce Git per tutte le operazioni di controllo della versione, ma semplifica solo le operazioni di Git complesse. Repo utilizza i file manifest per aggregare i progetti Git nel superprogetto Android.
file manifest: Un file manifest è un file XML che specifica dove sono posizionati i vari progetti Git nel codice sorgente di Android all'interno di una struttura ad albero del codice sorgente AOSP.

Soddisfare i requisiti hardware

La workstation di sviluppo deve soddisfare o superare i seguenti requisiti hardware:

Un sistema x86 a 64 bit.

Nota: puoi compilare le versioni AOSP precedenti alla 2.3.x su sistemi a 32 bit.
Almeno 400 GB di spazio libero su disco per il pagamento e la creazione del codice (250 GB per l'acquisto + 150 GB per la creazione).

Nota: se stai controllando un mirror, hai bisogno di più spazio perché i mirror completi del progetto open source Android (AOSP) contengono tutti i repository Git che sono mai stati utilizzati.
Almeno 64 GB di RAM. Google utilizza macchine con 72 core e 64 GB di RAM per compilare Android. Con questa configurazione hardware, sono necessari circa 40 minuti per una build completa di Android e solo pochi minuti per una build incrementale di Android. Al contrario, sono necessarie circa 6 ore per una compilazione completa con una macchina a 6 core con 64 GB di RAM.

Soddisfare i requisiti del sistema operativo

La tua workstation di sviluppo deve eseguire qualsiasi distribuzione Linux a 64 bit con GNU C Library (glibc) 2.17 o versioni successive.

Installa i pacchetti richiesti

Per installare i pacchetti obbligatori per Ubuntu 18.04 o versioni successive, esegui il seguente comando:

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

Installa il software richiesto

Prima di poter lavorare con AOSP, devi installare OpenJDK, Make, Python 3 e Repo. Il ramo principale AOSP di Android è dotato di versioni precompilate di OpenJDK, Make e Python 3, pertanto non sono necessari passaggi di installazione aggiuntivi. La sezione seguente spiega come installare Repo.

Installa Repo

Per installare Repo:

Scarica le informazioni sul pacchetto corrente:
```
sudo apt-get update
```
Esegui il seguente comando per installare il programma di lancio del repository:
```
sudo apt-get install repo
```
Il programma di lancio di Repo fornisce uno script Python che inizializza un controllo e scarica lo strumento Repo completo.

Se l'operazione è andata a buon fine, vai al passaggio 4.
(Facoltativo) Installa manualmente Repo utilizzando la seguente serie di comandi:
```
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
```
I primi tre comandi configurano un file temporaneo, scaricano il repository nel file e verificano che la chiave fornita corrisponda a quella richiesta. Se questi comandi vanno a buon fine, il comando finale installa il programma di lancio del repository.
Verifica la versione del programma di avvio del repository:
```
repo version
```
L'output dovrebbe indicare una versione 2.4 o successiva, ad esempio:

repo launcher version 2.45

Scaricare il codice sorgente di Android

Il codice sorgente di Android si trova in una raccolta di repository Git ospitati da Google. Ogni repository Git include l'intera cronologia del codice sorgente di Android, incluse le modifiche al codice sorgente e il momento in cui sono state apportate. Per scaricare il codice sorgente di Android:

Vai alla tua home directory:
```
cd ~
```
Crea una sottodirectory di lavoro locale al suo interno:
```
mkdir aosp
```
Vai alla directory:
```
cd aosp
```

Inizializza il ramo principale del codice sorgente del repository AOSP (predefinito):

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

Inserisci o accetta le tue credenziali Git (nome, indirizzo email).
Sincronizza il codice sorgente:
```
repo sync -c -j8
```
Se riscontri problemi durante il download, consulta Risolvere i problemi di sincronizzazione.

Compila il codice

Per compilare il codice:

Dalla directory di lavoro, esegui lo script envsetup.sh per configurare il tuo ambiente di compilazione:
```
source build/envsetup.sh
```

Specifica un tipo di dispositivo target da creare con il comando lunch. Un target è una permutazione del dispositivo, come un modello o un fattore di forma specifico. Specifica questo target:

lunch aosp_cf_x86_64_phone-trunk_staging-userdebug

Dovresti vedere un riepilogo del tuo ambiente di destinazione e di build:

============================================
PLATFORM_VERSION_CODENAME=VanillaIceCream
PLATFORM_VERSION=VanillaIceCream
PRODUCT_INCLUDE_TAGS=com.android.mainline
TARGET_PRODUCT=aosp_arm
TARGET_BUILD_VARIANT=eng
TARGET_ARCH=arm
TARGET_ARCH_VARIANT=armv7-a-neon
TARGET_CPU_VARIANT=generic
HOST_OS=linux
HOST_OS_EXTRA=Linux-6.5.13-1rodete2-amd64-x86_64-Debian-GNU/Linux-rodete
HOST_CROSS_OS=windows
BUILD_ID=AOSP.MAIN
OUT_DIR=out
============================================

Crea il target:
```
m
```

La prima compilazione potrebbe richiedere ore. Le build successive richiedono molto meno tempo. L'output della build viene visualizzato in $OUT_DIR.

Avvia Cuttlefish

Cuttlefish è l'emulatore Android utilizzato per testare le build.

Esegui i seguenti comandi per scaricare, compilare e installare i pacchetti Debian dell'host:

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

Il riavvio attiva l'installazione di ulteriori moduli del kernel e applica le regole udev.

Avvia Seppia:
```
launch_cvd --daemon
```
Connettiti al dispositivo Cuttlefish andando alla pagina https://localhost:8443 nel browser web. Viene mostrato il tuo dispositivo virtuale Android.

Effettua una modifica

Aggiorna il codice sorgente seguendo questo esempio di elenco di modifiche.

Dalla directory principale del pagamento (directory aosp/), vai al progetto Git frameworks/native:
```
cd frameworks/native
```
Avvia un progetto temporaneo con questo comando:
```
repo start <some-name> .
```
Utilizza l'editor per modificare SurfaceFlinger.cpp nella seguente posizione:
```
aosp/frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp
```

Trova questa riga:

void SurfaceFlinger::updateColorMatrixLocked() {

Aggiungi questa riga all'inizio di 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});

Compila il codice:
```
m
```

Aggiorna la build sul dispositivo:

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

Verifica di vedere una variazione di colore sul dispositivo selezionato simile a quella mostrata nella Figura 1.

Figura 1. Aspetto dello schermo dopo la modifica del colore

Correggere un test

Questa parte del codelab utilizza un test di esempio che si trova nella struttura ad albero della sorgente e non va a buon fine.

Per eseguire, eseguire il debug e correggere il test, segui queste istruzioni:

Esegui:
```
atest DevCodelabTest
```
Il test non va a buon fine.

Nota: atest è uno strumento a riga di comando che consente di compilare, installare ed eseguire test Android localmente.

Esamina l'analisi dello stack del test non riuscito:

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)

L'ultima riga della traccia dello stack mostra il test che non va a buon fine (testHelloWorld). Questo test si trova in un file denominato DevCodelabTest.java.

Per determinare la posizione del test da correggere, aggiungi WORKING_DIRECTORY/platform_testing/tests/example/devcodelab/src/ all'ultima riga della traccia dello stack fino al nome del file di test incluso. Pertanto, android.test.example.devcodelab.DevCodelabTest diventa WORKING_DIRECTORY/platform_testing/tests/example/devcodelab/src/android/test/example/devcodelab/DevCodelabTest.java.
Modifica platform_testing/tests/example/devcodelab/src/android/test/example/devcodelab/DevCodelabTest.java e sostituisci Assert.assertTrue(false) con Assert.assertTrue(true)
Esegui di nuovo il test per verificare di aver risolto il problema:
```
atest DevCodelabTest
```

Carica il codice per la revisione

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

Per la revisione del codice dei tuoi progetti in Git, utilizza il sistema di revisione del codice basato su web Gerrit.

Supponendo che tu abbia apportato le modifiche nel progetto frameworks/native, esegui questi comandi per caricarle:
```
cd frameworks/native
repo start codelab .
git add .
git commit
```
Inserisci quanto segue per il messaggio di commit:
```
Android codelab change
Test: manual atest
```

Carica la modifica:

repo upload

Se l'operazione è andata a buon fine, verrà visualizzato un messaggio simile al seguente:

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

Visualizzare la modifica in Gerrit

Per visualizzare la modifica in Gerrit, vai all'output del link nel terminale. Il link è simile al seguente:

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

Ripristina la modifica

Di solito, dopo il test, in fase di revisione e approvazione, invii la modifica in Gerrit e la unisci al repository. Per gli scopi di questo codelab, ripristina il tuo lavoro:

In Gerrit, fai clic su Abbandona.
Abbandona il ramo temporaneo associato nella directory del progetto frameworks/native (o nelle relative sottodirectory):
```
repo abandon codelab .
```
Ripristina le modifiche apportate al file di test. Poiché non hai eseguito repo start, git commit e repo upload sulla modifica del test, puoi reimpostare il file stesso. Supponendo che tu sia in aosp/platform_testing directory, utilizza il seguente comando per reimpostare il file:
```
git reset HEAD tests/example/devcodelab/src/android/test/example/devcodelab/DevCodelabTest.java
git checkout .
```

Con questo si conclude il codelab per lo sviluppo della piattaforma Android.

Richiedi assistenza

Se si verificano errori durante questo codelab, segnalali utilizzando il link Issue Tracker nella parte inferiore di qualsiasi pagina. Invia domande al gruppo android-building.

Digita ps -A | grep crosvm per verificare se crosvm è già in esecuzione. Se crossvm è in esecuzione, digita stop_cvd || true o kill crosvm con il PID del processo.