A partire dal 2026, per allinearci al nostro modello di sviluppo trunk stabile e garantire la stabilità della piattaforma per l'ecosistema, pubblicheremo il codice sorgente su AOSP nel secondo e nel quarto trimestre. Per compilare e contribuire ad AOSP, consigliamo di utilizzare android-latest-release anziché aosp-main. Il branch del manifest android-latest-release farà sempre riferimento alla release più recente pubblicata su AOSP. Per saperne di più, consulta la sezione Modifiche ad AOSP.

Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Inviare modifiche al codice

Questa pagina descrive l'intera procedura di invio di una modifica del codice all'Android Open Source Project (AOSP), inclusa la procedura per richiedere una revisione e monitorare le modifiche.

AOSP si basa su Gerrit, un sistema di revisione del codice basato sul web per i progetti che utilizzano Git.

Firmare i contratti di licenza per i contributori

Prima di contribuire con modifiche del codice per AOSP, devi leggere Contributor license agreements and headers e firmare uno dei seguenti contratti:

Se sei un singolo contributore che apporta contributi solo per tuo conto, firma il Contratto di licenza per i singoli contributori.
Se sei un dipendente che lavora per una società, assicurati che la tua azienda abbia firmato il Contratto di licenza per i contributori aziendali che ti autorizza ad apportare contributi per suo conto.

Avviare un ramo

Per ogni modifica del codice che intendi apportare, segui questi passaggi:

Avvia un nuovo ramo all'interno del repository Git pertinente. Un ramo non è una copia dei file originali, ma un puntatore a un commit specifico, il che rende la creazione di rami locali e il passaggio da uno all'altro un'operazione leggera. Utilizzando i rami, puoi identificare le modifiche l'una dall'altra. Esegui questo comando per avviare un ramo:
```
repo start BRANCH_NAME
```
Puoi avviare più rami indipendenti contemporaneamente nello stesso repository. Il ramo BRANCH_NAME è locale al tuo spazio di lavoro e non è incluso né in Gerrit né nell'albero di origine finale. I rami sono anche specifici del progetto in cui ti trovi, quindi se devi modificare i file in progetti diversi nell'ambito della stessa modifica, avrai bisogno di un ramo in ogni progetto in cui modifichi i file.
(Facoltativo) Verifica che il ramo sia stato creato:
```
repo status .
```
Dovresti vedere il ramo che hai appena creato. Ad esempio:
```
project frameworks/native/                      branch mynewbranch
```
Nota: puoi anche utilizzare repo branches per ottenere un elenco di tutti i rami, con il ramo corrente (se presente) preceduto da un asterisco (*).

Apportare e testare la modifica

Segui questi passaggi per apportare e testare la modifica:

Per assicurarti di lavorare con la codebase più recente, esegui una sincronizzazione dell'intera codebase:
```
repo sync
```
Nota: per sincronizzare solo il progetto corrente, aggiungi un punto (.) al repo sync comando: repo sync .. La sincronizzazione del progetto corrente è più veloce della sincronizzazione dell'intero repository.

Se si verificano conflitti durante la sincronizzazione, consulta i passaggi da 2 a 4 di Risolvere i conflitti di sincronizzazione.
Trova il codice da modificare. Per trovare il codice, valuta la possibilità di utilizzare la ricerca del codice Android. Puoi utilizzare la ricerca del codice Android per visualizzare il codice sorgente AOSP così come viene visualizzato quando lo utilizzi effettivamente. Per ulteriori informazioni, consulta la pagina Guida introduttiva a Code Search. Per visualizzare tutto il codice nel ramo della release AOSP più recente nella ricerca del codice Android, vai a https://cs.android.com/android/platform/superproject/.
Modifica o aggiungi file di origine. Per le modifiche apportate:
- Determina se devi utilizzare i flag di lancio delle funzionalità e, in caso affermativo, implementali per il nuovo codice.
- Segui le best practice descritte in Includere le intestazioni delle licenze.
- Per il codice Java, segui lo stile del codice Java AOSP per i contributori.
- Alcune parti di AOSP sono scritte in Kotlin (.kt) e puoi utilizzare Kotlin nelle aree della piattaforma già scritte in Kotlin. Per ulteriori informazioni su Kotlin in Android, consulta la guida di stile Kotlin per sviluppatori Android e la guida all'interoperabilità Kotlin-Java. Per indicazioni più complete su Kotlin, consulta il sito del linguaggio Kotlin.
- Quando scrivi le API, segui le linee guida per le API Android. Utilizza queste linee guida per vedere il contesto alla base delle decisioni sulle API di Android. Le aggiunte e le modifiche delle API della piattaforma vengono convalidate da Metalava.
Crea Android.
Testa la build.

Preparare ed eseguire il commit della modifica

Un commit è l'unità di base del controllo della revisione in Git e consiste in uno snapshot della struttura delle directory e dei contenuti dei file per l'intero progetto. Segui questi passaggi per eseguire il commit della modifica:

Per impostazione predefinita, Git registra le modifiche apportate, ma non le monitora. Per indicare a Git di monitorare le modifiche, devi contrassegnarle o prepararle per l'inclusione in un commit. Esegui questo comando per preparare la modifica:
```
git add -A
```
Questo comando monitora le modifiche apportate a qualsiasi file.

Nota: se vuoi monitorare solo le modifiche a un file specifico, utilizza git add filename.
Nota: oltre a monitorare le modifiche ai file, git add può essere utilizzato per eseguire altre operazioni, come la preparazione delle modifiche e delle eliminazioni dei file.
Prendi i file nell'area di preparazione ed esegui il commit o archiviali nel database locale:
```
git commit -s
```
Per impostazione predefinita, si apre un editor di testo e ti viene chiesto di fornire un messaggio di commit.
Fornisci un messaggio di commit nel seguente formato:
- Riga 1: titolo. Fornisci un riepilogo di una riga della modifica (massimo 50 caratteri). Valuta la possibilità di utilizzare i prefissi per descrivere l'area modificata, seguiti da una descrizione della modifica apportata in questo commit, come nell'esempio seguente contenente una modifica dell'interfaccia utente:
```
ui: Removes deprecated widget
```
- Riga 2: riga vuota. Dopo il titolo, inserisci una riga vuota.
- Riga 3: corpo. Fornisci una descrizione lunga con un massimo di 72 caratteri. Descrivi il problema risolto dalla modifica e in che modo. Sebbene il corpo sia facoltativo, è utile per gli altri che devono fare riferimento alla modifica. Assicurati di includere una breve nota su eventuali ipotesi o informazioni di base che potrebbero essere importanti quando un altro contributore lavora su questa funzionalità.
Per leggere un blog sulle buone descrizioni dei commit (con esempi), consulta l'articolo How to Write a Git Commit Message.
Salva il commit.

Un ID modifica univoco e il tuo nome ed indirizzo email, forniti durante repo init, vengono aggiunti automaticamente al messaggio di commit.

Caricare la modifica per la revisione

Dopo aver eseguito il commit della modifica nella cronologia Git personale, caricala in Gerrit:

Esegui il comando seguente per caricare tutti i commit in tutti i progetti:
```
repo upload
```
Tutte le modifiche in tutti i progetti sono incluse nel caricamento.

Nota: per caricare le modifiche solo nel progetto corrente, aggiungi un punto (.) al comando repo upload: repo upload ..
Nota: se stai lavorando a una modifica che richiede modifiche ai file in più progetti, utilizza un argomento in Gerrit per collegare le modifiche, indipendentemente dal fatto che utilizzi repo upload o repo upload .. L'argomento Gerrit garantisce che le modifiche vengano mantenute insieme ai fini dei test di pre-invio e tramite l'unione automatica. Per ulteriori informazioni, consulta la sezione Utilizzare gli argomenti

Ti viene chiesto di eseguire gli script hook.

Premi a e poi Invio.

Ti viene chiesto di approvare il caricamento:

Upload project frameworks/native/ to remote branch android17-release:
branch BRANCH_NAME ( 1 commit, Wed Aug 7 09:32:33 2019 -0700):
       ff46b36d android codelab change
to https://android-review.googlesource.com/ (y/N)?

Premi y e poi Invio per approvare il caricamento.

Dovresti ricevere un messaggio simile a remote: SUCCESS.

Richiedere una revisione

Dopo un caricamento riuscito, Repo ti fornisce un link alle modifiche in Gerrit. Fai clic sul link per visualizzare le modifiche sul server di revisione, aggiungere commenti o richiedere revisori specifici per la modifica. Tutte le modifiche al codice devono essere esaminate dai proprietari del codice appropriati.

Per richiedere una revisione:

In Gerrit, fai clic su SUGGERISCI PROPRIETARI:

Figura 1. Link Suggerisci proprietari in Gerrit.

Viene visualizzata la finestra di dialogo del revisore. Questa finestra di dialogo contiene un elenco di proprietari del codice che possono esaminare la modifica.
Fai clic su un proprietario del codice per aggiungerlo alla revisione.

Nota: per capire come vengono determinati i proprietari, consulta il backend find-owners.

Il pulsante INVIA è attivo.
(Facoltativo) Digita l'indirizzo email di chiunque altro tu voglia esaminare la modifica.
Fai clic su INVIA per inviare la modifica per la revisione.

I proprietari del codice esaminano le modifiche del codice e, se accettate, le selezionano e le uniscono al ramo di sviluppo interno.

Determinare lo stato della modifica

Per determinare lo stato dei file nella modifica, controlla le seguenti icone accanto ai file nella modifica:

(icona del segno di spunta ): approvato dal proprietario del codice
(icona della croce): non approvato dal proprietario del codice
(icona dell'orologio ): in attesa di approvazione da parte del proprietario del codice

La figura seguente mostra queste icone di stato applicate ai file in una modifica:

Esempio di file con icone che mostrano l'approvazione del proprietario del codice

Figura 2. Esempio di file con icone che mostrano l'approvazione del proprietario del codice.

Risolvere il feedback e caricare una modifica sostitutiva

Se un revisore richiede una modifica all'aggiornamento, puoi modificare il commit in Git, il che comporta un nuovo patchset sulla stessa modifica.

Per risolvere il feedback e modificare la modifica:

Segui i passaggi da 2 a 4 in Apportare e testare la modifica.
Esegui i seguenti comandi per modificare la modifica:
```
git add -A
git commit --amend
```
Carica la modifica.

Quando carichi la modifica modificata, questa sostituisce l'originale sia in Gerrit sia nella cronologia Git locale.

Risolvere i conflitti di sincronizzazione

Se vengono inviate altre modifiche all'albero di origine in conflitto con le tue, riceverai un messaggio che indica la presenza di conflitti. Per risolvere i conflitti:

Assicurati di lavorare con il codice più recente:
```
repo sync .
```
Il comando repo sync recupera gli aggiornamenti dal server di origine, quindi tenta di eseguire automaticamente il rebase di HEAD sul nuovo HEAD remoto.
Se il rebase automatico non va a buon fine, esegui un rebase manuale:
```
repo rebase .
```
Risolvi i conflitti di unione. Se non hai un metodo preferito per risolvere i conflitti di unione, puoi utilizzare git mergetool per correggere manualmente i conflitti tra i file.
Dopo aver corretto correttamente i file in conflitto, esegui questo comando per applicare i nuovi commit:
```
git rebase --continue
```

Inviare la modifica

Dopo che un invio ha superato la procedura di revisione e verifica, il proprietario del codice invia il codice per tuo conto, nel ramo in cui è stata esaminata la modifica o in un ramo interno.

Dopo l'unione dell'invio, puoi visitare la dashboard di integrazione continua di Android per monitorare quando gli invii vengono integrati nell'albero.