Versões Java em builds do Android

Não importa se o código-fonte foi escrito em Java, Kotlin ou ambos. há vários locais em que é preciso escolher uma linguagem JDK ou Java para seu build.

Glossário

Kit de desenvolvimento Java (JDK)

O Kit de desenvolvimento em Java (JDK) contém:

• Ferramentas, como compilador, criador de perfil e criador de arquivos. Elas são usadas em segundo plano durante o build para para criar o aplicativo.
• Bibliotecas contendo APIs que você pode chamar do seu Código-fonte Kotlin ou Java. Nem todas as funções são disponíveis no Android.
• A máquina virtual Java (JVM), um intérprete que executa aplicativos Java. Usar a JVM para executar o ambiente de desenvolvimento integrado do Android Studio e a ferramenta de build do Gradle. A JVM não é usada no Android. dispositivos ou emuladores.

Ambiente de execução da JetBrains (JBR)

O JetBrains Runtime (JBR) é um JDK aprimorado, distribuído com o Android Studio. está disponível e inclui várias otimizações para uso no Studio e no JetBrains relacionado. mas também podem ser usados para executar outros aplicativos Java.

Como escolher um JDK para executar o Android Studio?

Recomendamos que você use o JBR para executar o Android Studio. Ele está implantado que são usadas para testar o Android Studio e inclui melhorias para otimizar Uso do Android Studio. Para garantir isso, não defina o STUDIO_JDK variável de ambiente.

Os scripts de inicialização do Android Studio procuram uma JVM no seguinte ordem:

1. Variável de ambiente STUDIO_JDK
2. Diretório studio.jdk (na distribuição do Android Studio)
3. Diretório jbr (JetBrains Runtime), no Android Studio e distribuição de dados. Recomendado.
4. Variável de ambiente JDK_HOME
5. Variável de ambiente JAVA_HOME
6. java executável na variável de ambiente PATH

Como escolho qual JDK executa meus builds do Gradle?

Se você executar o Gradle usando os botões no Android Studio, o JDK definido no arquivo As configurações do Android Studio são usadas para executar o Gradle. Se você executar o Gradle em um terminal, dentro ou fora do Android Studio, a variável de ambiente JAVA_HOME (se definido) determina qual JDK executa os scripts do Gradle. Se JAVA_HOME não estiver definido, ele usará o comando java no seu ambiente PATH variável.

Para resultados mais consistentes, defina seu JAVA_HOME variável de ambiente Configuração do Gradle JDK no Android Studio para a mesma JDK.

Ao executar o build, o Gradle cria um processo chamado daemon para para executar o build real. Esse processo pode ser reutilizado, desde que os builds estejam usando a mesma versão do JDK e do Gradle. Reutilizar um daemon reduz o tempo para iniciar uma nova JVM e inicializar o sistema de build.

Se você iniciar builds com diferentes versões do JDK ou Gradle, outras daemons são criados, consumindo mais CPU e memória.

Configuração do JDK do Gradle no Android Studio

Para modificar a configuração do Gradle JDK do projeto atual, abra o arquivo configurações em File (ou Android Studio no macOS) > Configurações > Criação, execução, implantação > Ferramentas de build > Gradle. O Gradle JDK (link em inglês) o menu suspenso contém as seguintes opções:

• Macros, como JAVA_HOME e GRADLE_LOCAL_JAVA_HOME.
• Entradas da tabela JDK no formato vendor-version, como jbr-17, que são armazenadas. nos arquivos de configuração do Android
• Como fazer o download de um JDK
• Como adicionar um JDK específico
• JDKs detectados localmente na instalação padrão do JDK do sistema operacional diretório

A opção selecionada é armazenada na opção gradleJvm no no arquivo .idea/gradle.xml do projeto, e a resolução de caminho JDK é usada para executar Gradle quando iniciado pelo Android Studio

As macros ativam a seleção de caminho dinâmico do JDK do projeto:

• JAVA_HOME: usa a variável de ambiente com o mesmo nome.
• GRADLE_LOCAL_JAVA_HOME: usa a propriedade java.home em o arquivo .gradle/config.properties, que tem como padrão o ambiente de execução do JetBrains.

O JDK selecionado é usado para executar o build do Gradle e resolver a JDK API. referências ao editar scripts de build e código-fonte. Observe que o compileSdk especificado restringirá ainda mais quais símbolos Java serão disponíveis ao editar e criar seu código-fonte.

Escolha uma versão do JDK maior ou igual a ela são as versões usadas pelos plug-ins usados no seu build do Gradle. Para determinar versão mínima necessária do JDK para o Plug-in do Android para Gradle (AGP), consulte as nas notas da versão.

Por exemplo, o Plug-in do Android para Gradle versão 8.x exige o JDK 17. Se você tentar executar um build do Gradle que o usa com uma versão anterior do o JDK, ele informa uma mensagem como:

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/jdk11
      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`.

Quais APIs Java posso usar no meu código-fonte Java ou Kotlin?

Um aplicativo Android pode usar algumas das APIs definidas em um JDK, mas não todas um deles. O SDK do Android define implementações de muitas funções da biblioteca Java como parte das APIs disponíveis. A propriedade compileSdk especifica quais Versão do SDK do Android a ser usada ao compilar seu código-fonte em Kotlin ou Java.

android {
    ...
    compileSdk = 33
}

android {
    ...
    compileSdk 33
}

Cada versão do Android suporta uma versão específica do JDK e um subconjunto de as APIs Java disponíveis. Se você usa uma API Java que está disponível no um compileSdk que não está disponível no minSdk, talvez seja possível usar a API na versão anterior do Android por um processo conhecido como simplificação de leitura. Consulte as APIs Java 11+ disponíveis por simplificação para conferir os suportes APIs de terceiros.

Use esta tabela para determinar qual versão do Java é compatível com cada API do Android e onde encontrar detalhes sobre quais APIs Java estão disponíveis.

Qual JDK compila meu código-fonte em Java?

O conjunto de ferramentas Java JDK contém o compilador Java usado para compilar qualquer linguagem o código-fonte. Esse JDK também executa testes de unidade e do javadoc durante a compilação.

O padrão do conjunto de ferramentas é o JDK usado para executar o Gradle. Se você usar o padrão e executar um build em máquinas diferentes (por exemplo, a máquina local e um servidor de integração contínua separado), os resultados da sua compilação podem diferir se diferentes versões do JDK forem usadas.

Para criar um build mais consistente, é possível especificar explicitamente um Versão do conjunto de ferramentas do Java. Especificar isso:

• Localiza um JDK compatível no sistema que está executando o build.
  • Se não houver um JDK compatível (e um resolvedor de conjunto de ferramentas estiver definido), faz o download de um.
• Expõe as APIs Java do conjunto de ferramentas para chamadas do código-fonte.
• Compila o código-fonte Java usando a versão da linguagem Java.
• Padrões de suprimentos para sourceCompatibility e targetCompatibility

Recomendamos que você sempre especifique o conjunto de ferramentas Java e verifique se o JDK especificado está instalado ou adicione um resolvedor do conjunto de ferramentas ao seu build.

É possível especificar o conjunto de ferramentas independentemente de o código-fonte estar escrito em Java, Kotlin ou ambos. Especifique o conjunto de ferramentas no nível superior do módulo build.gradle(.kts).

Especifique a versão do conjunto de ferramentas do Java desta forma:

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

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

Isso funciona se a origem for Kotlin, Java ou uma combinação dos dois.

A versão do JDK do conjunto de ferramentas pode ser igual ao JDK usado para executar o Gradle, mas mas lembre-se de que elas têm propósitos diferentes.

Quais recursos-fonte da linguagem Java posso usar no meu código-fonte Java?

A propriedade sourceCompatibility determina quais recursos da linguagem Java disponíveis durante a compilação da fonte Java. Ele não afeta a origem do Kotlin.

Se não for especificado, o padrão será o conjunto de ferramentas Java ou JDK usado para executar o Gradle. Recomendamos sempre especificar explicitamente um conjunto de ferramentas (preferencial) ou sourceCompatibility.

Especifique sourceCompatibility no arquivo build.gradle(.kts) do módulo.

android {
    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_17
    }
}

android {
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_17
    }
}

Quais recursos binários Java podem ser usados quando eu compilo minha fonte Kotlin ou Java?

Especificar targetCompatibility e jvmTarget determina o Java Versão em formato de classe usada ao gerar bytecode para Java e Kotlin compilados , respectivamente.

Alguns recursos do Kotlin já existiam antes da adição de recursos Java equivalentes. Os primeiros compiladores do Kotlin precisaram criar a própria maneira de representar esses códigos atributos de machine learning. Alguns desses recursos foram adicionados posteriormente ao Java. Com níveis jvmTarget posteriores, o compilador Kotlin pode usar diretamente o recurso Java, o que pode resultar em um desempenho melhor.

O padrão de targetCompatibility é o mesmo valor que sourceCompatibility, mas, se especificado, precisa ser maior ou igual a sourceCompatibility.

jvmTarget tem como padrão a versão do conjunto de ferramentas.

Diferentes versões do Android oferecem suporte a diferentes versões do Java. Você pode aproveitar recursos adicionais do Java aumentando targetCompatibility e jvmTarget, mas isso pode forçar você a também aumente sua versão mínima do SDK do Android para garantir quando o recurso estiver disponível.

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

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