Versioni Java nelle build Android

Indipendentemente dal fatto che il codice sorgente sia scritto in Java, Kotlin o in entrambi, in diversi punti devi scegliere una versione del linguaggio JDK o Java per la tua build.

Glossario

Java Development Kit (JDK)

Java Development Kit (JDK) contiene:

• Strumenti, come compilatori, profiler e creator di archivi. Questi vengono utilizzati dietro le quinte durante la compilazione per creare l'applicazione.
• Librerie contenenti API che puoi chiamare dal codice sorgente Kotlin o Java. Tieni presente che non tutte le funzioni sono disponibili su Android.
• La Java Virtual Machine (JVM), un interprete che esegue applicazioni Java. Utilizzi la JVM per eseguire l'IDE Android Studio e lo strumento di compilazione Gradle. La JVM non viene utilizzata su dispositivi o emulatori Android.

JetBrains Runtime (JBR)

JetBrains Runtime (JBR) è un JDK migliorato, distribuito con Android Studio. Include diverse ottimizzazioni per l'utilizzo in Studio e nei prodotti correlati di JetBrains, ma può essere utilizzato anche per eseguire altre applicazioni Java.

Come faccio a scegliere un JDK per eseguire Android Studio?

Ti consigliamo di utilizzare JBR per eseguire Android Studio. Viene eseguito il deployment con Android Studio e utilizzato per testarlo e include miglioramenti per un utilizzo ottimale di Android Studio. Per assicurarti che ciò accada, non impostare la variabile di ambiente STUDIO_JDK.

Gli script di avvio di Android Studio cercano una JVM nel seguente ordine:

1. Variabile di ambiente STUDIO_JDK
2. Directory studio.jdk (nella distribuzione di Android Studio)
3. jbr (JetBrains Runtime), nella distribuzione di Android Studio. Consigliata.
4. Variabile di ambiente JDK_HOME
5. Variabile di ambiente JAVA_HOME
6. java eseguibile nella variabile di ambiente PATH

Come faccio a scegliere quale JDK esegue le mie build di Gradle?

Se esegui Gradle utilizzando i pulsanti in Android Studio, per l'esecuzione di Gradle viene utilizzato il JDK impostato nelle impostazioni di Android Studio. Se esegui Gradle in un terminale, all'interno o all'esterno di Android Studio, la variabile di ambiente JAVA_HOME (se impostata) determina quale JDK esegue gli script Gradle. Se JAVA_HOME non è impostato, viene utilizzato il comando java sulla variabile di ambiente PATH.

Per risultati più coerenti, assicurati di impostare la JAVA_HOME variabile di ambiente e la configurazione JDK di Gradle in Android Studio sullo stessoJDK.

Quando esegui la build, Gradle crea un processo chiamato demone per eseguire la build effettiva. Questo processo può essere riutilizzato, purché le build utilizzino la stessa versione di JDK e Gradle. Il riutilizzo di un daemon riduce il tempo necessario per avviare una nuova JVM e inizializzare il sistema di compilazione.

Se avvii le build con versioni diverse di JDK o Gradle, vengono creati daemon aggiuntivi che consumano più CPU e memoria.

Configurazione di JDK Gradle in Android Studio

Per modificare la configurazione JDK di Gradle del progetto esistente, apri le impostazioni di Gradle da File (o Android Studio su macOS) > Impostazioni > Compilazione, esecuzione, deployment > Strumenti di compilazione > Gradle. Il menu a discesa Gradle JDK contiene le seguenti opzioni tra cui scegliere:

• Macro come JAVA_HOME e GRADLE_LOCAL_JAVA_HOME
• Le voci della tabella JDK in formato vendor-version come jbr-17 archiviate nei file di configurazione di Android
• Download di un JDK
• Aggiunta di un JDK specifico
• JDK rilevati localmente dalla directory di installazione JDK predefinita del sistema operativo

L'opzione selezionata viene memorizzata nell'opzione gradleJvm nel file .idea/gradle.xml del progetto e la relativa risoluzione del percorso JDK viene utilizzata per eseguire Gradle quando viene avviato tramite Android Studio.

Le macro consentono di selezionare il percorso del JDK del progetto dinamico:

• JAVA_HOME: utilizza la variabile di ambiente con lo stesso nome
• GRADLE_LOCAL_JAVA_HOME: utilizza la proprietà java.home nel file .gradle/config.properties, che per impostazione predefinita è il runtime JetBrains.

Il JDK selezionato viene utilizzato per eseguire la build di Gradle e risolvere i riferimenti alle API JDK quando modifichi gli script di build e il codice sorgente. Tieni presente che il valore compileSdk specificato limiterà ulteriormente i simboli Java disponibili durante la modifica e la compilazione del codice sorgente.

Assicurati di scegliere una versione JDK superiore o uguale alle versioni JDK utilizzate dai plug-in che utilizzi nella compilazione Gradle. Per determinare la versione JDK minima richiesta per il plug-in Android per Gradle (AGP), consulta la tabella di compatibilità nelle note di rilascio.

Ad esempio, il plug-in Android per Gradle versione 8.x richiede JDK 17. Se provi a eseguire una compilazione Gradle che lo utilizza con una versione precedente delJDK, viene visualizzato un messaggio simile al seguente:

An exception occurred applying plugin request [id: 'com.android.application']
> Failed to apply plugin 'com.android.internal.application'.
   > Android Gradle plugin requires Java 17 to run. You are currently using Java 11.
      Your current JDK is located in /usr/local/buildtools/java/jdk
      You can try some of the following options:
       - changing the IDE settings.
       - changing the JAVA_HOME environment variable.
       - changing `org.gradle.java.home` in `gradle.properties`.

Quali API Java posso utilizzare nel mio codice sorgente Java o Kotlin?

Un'applicazione Android può utilizzare alcune delle API definite in un JDK, ma non tutte. L'SDK Android definisce le implementazioni di molte funzioni della libreria Java come parte delle API disponibili. La proprietà compileSdk specifica la versione dell'SDK Android da utilizzare durante la compilazione del codice sorgente Kotlin o Java.

android {
    ...
    compileSdk = 33
}

android {
    ...
    compileSdk 33
}

Ogni versione di Android supporta una versione specifica del JDK e un sottoinsieme delle sue API Java disponibili. Se utilizzi un'API Java disponibile in un compileSdk non disponibile nel minSdk specificato, potresti essere in grado di utilizzare l'API nella versione precedente di Android tramite un processo noto come desugaring. Per le API supportate, consulta API Java 11 e versioni successive disponibili tramite la desugaring.

Utilizza questa tabella per determinare quale versione di Java è supportata da ogni API Android e dove trovare i dettagli sulle API Java disponibili.

Quale JDK compila il mio codice sorgente Java?

Il JDK della toolchain Java contiene il compilatore Java utilizzato per compilare qualsiasi codice sorgente Java. Questo JDK esegue anche javadoc e test di unità durante la compilazione.

La toolchain predefinita è il JDK utilizzato per eseguire Gradle. Se utilizzi il valore predefinito e esegui una compilazione su macchine diverse (ad esempio la tua macchina locale e un server di integrazione continua separato), i risultati della compilazione possono variare se vengono utilizzate versioni diverse di JDK.

Per creare una build più coerente, puoi specificare esplicitamente una versione della toolchain Java. Specificando quanto segue:

• Individua un JDK compatibile sul sistema su cui viene eseguita la compilazione.
  • Se non esiste un JDK compatibile (e è definito un risolutore della toolchain), ne scarica uno.
• Espone le API Java della toolchain per le chiamate dal codice sorgente.
• Compila il codice sorgente Java utilizzando la relativa versione del linguaggio Java.
• I valori predefiniti per le forniture sono sourceCompatibility e targetCompatibility.

Ti consigliamo di specificare sempre la toolchain Java e di assicurarti che sia installato il JDK specificato o di aggiungere un risolvere toolchain alla compilazione.

Puoi specificare la toolchain se il codice sorgente è scritto in Java, Kotlin o in entrambi i linguaggi. Specifica la toolchain al livello superiore del file build.gradle(.kts) del modulo.

Specifica la versione della toolchain Java come segue:

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(17)
    }
}

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(17)
    }
}

Questo funziona se il codice sorgente è Kotlin, Java o una combinazione di entrambi.

La versione JDK della toolchain può essere la stessa utilizzata per eseguire Gradle, ma tieni presente che hanno scopi diversi.

Quali funzionalità del codice sorgente Java posso utilizzare nel mio codice sorgente Java?

La proprietà sourceCompatibility determina quali funzionalità del linguaggio Java sono disponibili durante la compilazione del codice sorgente Java. Non influisce sul codice sorgente Kotlin.

Specifica sourceCompatibility nel file build.gradle(.kts) del modulo come segue:

android {
    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_17
    }
}

android {
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_17
    }
}

Se non specificato, il valore predefinito di questa proprietà è la versione della toolchain Java. Se non utilizzi una toolchain Java, viene utilizzata per impostazione predefinita una versione scelta dal plug-in Gradle per Android (ad esempio Java 8 o versioni successive).

Quali funzionalità di file binari Java posso utilizzare quando compilo il codice sorgente Kotlin o Java?

Le proprietà targetCompatibility e jvmTarget determinano la versione del formato della classe Java utilizzata per generare il bytecode rispettivamente per il codice sorgente Java e Kotlin compilato.

Alcune funzionalità di Kotlin esistevano prima che fossero aggiunte le funzionalità Java equivalenti. I primi compilatori Kotlin dovevano creare il proprio modo per rappresentare queste funzionalità Kotlin. Alcune di queste funzionalità sono state aggiunte in un secondo momento a Java. Con i livelli jvmTarget successivi, il compilatore Kotlin potrebbe utilizzare direttamente la funzionalità Java, il che potrebbe comportare un rendimento migliore.

Versioni diverse di Android supportano versioni diverse di Java. Puoi usufruire di funzionalità Java aggiuntive aumentando targetCompatibility e jvmTarget, ma questo potrebbe obbligarti anche ad aumentare la versione minima dell'SDK Android per assicurarti che la funzionalità sia disponibile.

Tieni presente che targetCompatibility deve essere maggiore o uguale a sourceCompatibility. In pratica, in genere sourceCompatibility, targetCompatibility e jvmTarget devono utilizzare lo stesso valore. Puoi impostarli come segue:

android {
    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_17
        targetCompatibility = JavaVersion.VERSION_17
    }
    kotlinOptions {
        jvmTarget = "17"
    }
}

android {
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_17
        targetCompatibility JavaVersion.VERSION_17
    }
    kotlinOptions {
        jvmTarget '17'
    }
}

Se non specificate, queste proprietà hanno come valore predefinito la versione della toolchain Java. Se non utilizzi una toolchain Java, i valori predefiniti potrebbero essere diversi e causare problemi di compilazione. Pertanto, ti consigliamo di specificare sempre esplicitamente questi valori o di utilizzare una toolchain Java.