G8

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, d8 prevede che il bytecode Java di input include queste informazioni. Ad esempio, se utilizzi javac per compilare il codice, devi passare il flag -g per includere le informazioni di debug nel bytecode Java di output.

Quando compili file DEX per la versione di release dell'app o usa invece il flag --release.
--release

Compila il bytecode DEX senza informazioni di debug. Tuttavia, d8 include alcune informazioni che vengono utilizzate durante la generazione analisi dello stack ed eccezioni di logging.

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, d8 restituisce i file DEX nell'ambiente di lavoro corrente .

Se specifichi un percorso e un nome per un file ZIP o JAR, d8 crea il file specificato e include i file DEX di output. Se specifica il percorso di una directory esistente, d8 restituisce la DEX in quella directory.

--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 --main-dex-list.

--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 d8 deve includere nel file DEX principale, che in genere è denominato classes.dex. Se non specifichi un elenco di classi che usano questo flag, d8 non garantisce quali corsi sono inclusi nella richiesta principale DEX.

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 --main-dex-list, d8 include solo quelle nel file DEX principale. Serve per risolvere problemi relativi ai corsi mancante dal file DEX principale, più facile da eseguire. Se specifichi Modalità --release, d8 cerca di ridurre il numero di file DEX pacchettizzati nella versione di release della tua app includere il maggior numero possibile di altre classi nel file DEX principale fino a quando viene raggiunto il limite di 64.000.

Non puoi usare questo flag specificando anche --file-per-class.

--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 file.

--force-enable-assertions [:class_or_package_name...]

--force-ea [:class_or_package_name...]

 Attiva in modo forzato il codice di asserzione generato da javac.

--force-disable-assertions [:class_or_package_name...]

--force-da [:class_or_package_name...]

 Disattiva forzatamente il codice di asserzione generato da javac. Questo è la gestione predefinita del codice di asserzione javac quando generando file DEX.

--force-passthrough-assertions [:class_or_package_name...]

--force-pa [:class_or_package_name...]

 Non modificare il codice di asserzione generato da javac. Questo è la gestione predefinita del codice di asserzione javac quando generazione di class file.

--force-assertions-handler:handler method [:class_or_package_name...]

--force-ah:handler method [:class_or_package_name...]

 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