d8 è uno strumento a riga di comando di Android Studio e del plug-in Android Gradle
usa per compilare il bytecode Java del tuo progetto in bytecode DEX che viene eseguito
sui dispositivi Android. d8 ti consente di utilizzare le funzionalità del linguaggio Java 8 nel tuo
il codice dell'app.
d8 è incluso anche come strumento autonomo in Android Build
Strumenti 28.0.1 e successivi:
android_sdk/build-tools/version/.
Uso generico
d8 richiede solo un percorso al bytecode Java compilato
che vuoi convertire in bytecode DEX. Ad esempio:
d8 MyProject/app/build/intermediates/classes/debug/*/*.class
Il bytecode di input può essere in qualsiasi combinazione di file *.class o
di container, come file JAR, APK o ZIP. Puoi anche includere
File DEX per d8 da unire nell'output DEX, il che è utile
quando includi l'output di una build incrementale.
Per impostazione predefinita, d8 compila il bytecode Java in file DEX ottimizzati
e include informazioni di debug che puoi
per eseguire il debug del codice durante il runtime. Tuttavia, puoi includere attributi facoltativi
per eseguire una build incrementale, specifica le classi
devono essere compilati nel file DEX principale e specificare i percorsi
risorse aggiuntive necessarie per utilizzare le funzionalità del linguaggio Java 8.
d8 path-to-input-files [options]
Nella tabella seguente vengono descritti i flag facoltativi che puoi utilizzare con d8:
| Opzione | Descrizione |
|---|---|
--debug
|
Compila il bytecode DEX per includere le informazioni di debug, ad esempio il simbolo di debug tabelle. Questa opzione è abilitata per impostazione predefinita. Per includere le informazioni di debug nei tuoi
Bytecode DEX, Quando compili file DEX per la versione di release dell'app o
usa invece il flag |
--release
|
Compila il bytecode DEX senza informazioni di debug. Tuttavia,
Passa questo flag durante la compilazione del bytecode per una release pubblica. |
--output path
|
Specifica il percorso desiderato per l'output DEX. Per impostazione predefinita,
Se specifichi un percorso e un nome per un file ZIP o JAR, |
--lib android_sdk/platforms/api-level/android.jar
|
Specifica il percorso di android.jar del tuo SDK Android.
Questo flag è obbligatorio durante la compilazione di bytecode che utilizzano
Funzionalità del linguaggio Java 8.
|
--classpath path
|
Specifica le risorse classpath che d8 potrebbe richiedere per la compilazione
i file DEX del tuo progetto. In particolare, d8 richiede che tu
specificare determinate risorse durante la compilazione di bytecode che utilizza
Funzionalità del linguaggio Java 8.
|
--min-api number
|
Specifica il livello API minimo che deve essere supportato dai file DEX di output. |
--intermediate
|
Supera questo flag per comunicare a d8 che non stai compilando il file
un set completo di bytecode Java del tuo progetto. Questo flag è utile quando
l'esecuzione di build incrementali. Anziché compilare file DEX ottimizzati
che dovrebbero essere eseguiti su un dispositivo, d8 crea una
DEX e li archivia nell'output specificato o nel percorso predefinito.
Per compilare dei file DEX da eseguire su un dispositivo, escludi questo flag e specifica il percorso delle classi DEX intermedie come input. |
--file-per-class
|
Compila ogni classe in file DEX separati. L'attivazione di questo flag consente di eseguire più build incrementali a ricompilare solo i corsi che sono stati modificati. Durante l'esecuzione di build incrementali usando il plug-in Android Gradle, questa ottimizzazione sono abilitate per impostazione predefinita. Non puoi usare questo flag specificando anche
|
--no-desugaring
|
Disattiva le funzionalità del linguaggio Java 8. Utilizza questo flag solo se non intendi per compilare bytecode Java che utilizza caratteristiche del linguaggio Java 8. |
--main-dex-list path
|
Specifica un file di testo che elenca le classi che Poiché il sistema Android carica per primo il file DEX principale all'avvio nella tua app, puoi usare questo flag per dare la priorità a determinati corsi all'avvio compilandoli nel file DEX principale. Ciò è particolarmente utile quando si supporta il multidex legacy, perché solo le classi nel file DEX principale sono disponibili in fase di runtime fino a quando la libreria multidex legacy è caricato. Ricorda che ogni file DEX deve comunque soddisfare le
il limite di riferimento di 64.000. Quindi
specificare troppe classi per il file DEX principale o si ottiene
di compilazione. Per impostazione predefinita, quando specifichi classi utilizzando
Non puoi usare questo flag specificando anche
|
--pg-map file
|
Usa file come file di mappatura per la distribuzione. |
--file-per-class-file
|
Produci un file DEX separato per ciascun file .class di input. Mantieni i corsi sintetici con quello di origine. |
--desugared-lib file
|
Specifica una configurazione della libreria di destinazione. file è un file di configurazione della libreria desugato in JSON formato. |
--main-dex-rules file
|
ProGuardiamo le regole per le classi da inserire nel DEX principale. |
--main-dex-list-output file
|
Output dell'elenco DEX principale risultante in |
|
|
Attiva in modo forzato il codice di asserzione generato da javac.
|
|
|
Disattiva forzatamente il codice di asserzione generato da javac. Questo
è la gestione predefinita del codice di asserzione javac quando
generando file DEX.
|
|
|
Non modificare il codice di asserzione generato da javac. Questo
è la gestione predefinita del codice di asserzione javac quando
generazione di class file.
|
|
|
Modifica l'asserzione generata da javac e kotlinc
per richiamare il metodo handler method con ogni asserzione
anziché generarlo. Il valore handler method è specificato
come nome della classe seguito da un punto e dal nome del metodo. La
deve prendere un singolo argomento di tipo
java.lang.Throwable e il tipo restituito è void.
|
--thread-count number of threads
|
Specifica il numero di thread da utilizzare per la compilazione. Se non specificato, il numero si basa su un'euristica, prendendo il numero di core. |
--map-diagnostics[
:type] from-level to-level
|
Diagnostica mappa di type (impostazione predefinita qualsiasi) segnalata come Da from-level a to-level, dove from-level e to-level sono uno di "informazioni", "avviso" o "errore" e ai (facoltativo) type è il campo semplice o completo Nome del tipo Java di una diagnostica. Se il campo type non è specificato, tutti i dati diagnostici in from-level sono mappati. Tieni presente che gli errori irreversibili del compilatore non possono essere mappati. |
--version
|
Stampa la versione di d8 che stai utilizzando.
|
--help
|
Stampa il testo della guida per l'utilizzo di d8.
|
Esegui build incrementali
Per migliorare la velocità della build durante lo sviluppo, ad esempio per l'integrazione continua
indica a d8 di compilare solo un sottoinsieme delle risorse Java
in bytecode. Ad esempio, se abiliti il dexing per classe, puoi ricompilare solo
le classi che hai modificato dalla build precedente.
Il comando seguente esegue una build incrementale di alcune classi e abilita disintossicazione per classe. Il comando specifica inoltre una directory di output per una build incrementale.
d8 MainActivity.class R.class --intermediate --file-per-class --output ~/build/intermediate/dex
Quando d8 esegue una build incrementale, memorizza ulteriori informazioni nel
Output DEX. In seguito, d8 utilizzerà queste informazioni per elaborare correttamente
--main-dex-list e unire i file DEX durante una build completa della tua app.
Ad esempio, durante l'elaborazione delle classi lambda Java 8, d8 tiene traccia di quali
vengono create classi lambda per ogni classe di input. Durante una build completa, quando d8
include una classe nel file DEX principale, consulta i metadati per garantire
delle classi lambda create per quella classe sono incluse anche nelle
DEX.
Se hai già compilato tutti i bytecode del tuo progetto in file DEX
in più build incrementali, esegui una build completa passando
di file DEX intermedi in d8, come mostrato nel seguente comando.
Inoltre, puoi specificare i corsi che d8 deve compilare nel
DEX utilizzando --main-dex-list. Poiché l'input è un insieme di file che vengono
già compilata in bytecode DEX, questa build dovrebbe essere completata più velocemente
rispetto a una build pulita.
d8 ~/build/intermediate/dex --release --main-dex-list ~/build/classes.txt --output ~/build/release/dex
Compila bytecode che utilizza caratteristiche del linguaggio Java 8
d8 ti consente di utilizzare le funzionalità del linguaggio Java 8
nel tuo codice tramite un processo di compilazione chiamato desugaring. Desugaring effettua una conversione
utili caratteristiche del linguaggio in bytecode che possono essere eseguiti
completamente gestita.
Android Studio e il plug-in Android Gradle includono classpath
necessarie per abilitare la desugaring per te da d8. Tuttavia, quando utilizzi
d8 dalla riga di comando, devi includerli manualmente.
Una di queste risorse è il android.jar del tuo SDK Android target. Questo
include un insieme di API della piattaforma Android. Specifica il percorso utilizzando
il flag --lib.
Un'altra risorsa è l'insieme di bytecode Java compilato nel tuo progetto che attualmente non stanno compilando il bytecode DEX, ma richiedono di compilare altri in bytecode DEX.
Ad esempio, se il codice utilizza
predefiniti e statici, che sono un'interfaccia Java
8 lingue, devi usare questo flag per specificare il percorso di tutti i tuoi
bytecode Java del progetto, anche se non intendi compilare tutto il bytecode
in bytecode DEX. Questo perché d8 richiede queste informazioni per comprendere
del codice del tuo progetto e risolvere le chiamate ai metodi dell'interfaccia.
Il seguente esempio di codice esegue una build incrementale di una classe che accede un metodo di interfaccia predefinito:
d8 MainActivity.class --intermediate --file-per-class --output ~/build/intermediate/dex --lib android_sdk/platforms/api-level/android.jar --classpath ~/build/javac/debug