Complete Guide to Specifying JDK Version in Android Studio

Problem Background and Error Analysis

During Android development, developers often encounter build errors related to JDK versions. A typical error message appears as: Error:(3, 22) compileSdkVersion android-22 requires compiling with JDK 7. This error indicates that the project's configured compileSdkVersion requires JDK 7 or higher for compilation, but the current environment uses an incompatible JDK version.

JDK Location Configuration Methods

To resolve this issue, the first step is to correctly configure the JDK location in Android Studio. Follow these steps:

On macOS, use the shortcut cmd + , to open the settings dialog; on Windows/Linux, use Ctrl + Alt + S. Then navigate to the "Build, Execution, Deployment > Build Tools > Gradle" section.

In the Gradle settings, locate the "Gradle JDK" configuration option. This provides multiple selection methods:

• Use macro variables like JAVA_HOME and GRADLE_LOCAL_JAVA_HOME
• Select from installed JDK table entries
• Download a new JDK version
• Manually add a specific JDK path
• Use automatically detected JDKs from the system

Finding JDK Installation Path

If the specific JDK installation location is unknown, use terminal commands to locate it. On macOS, run:

/usr/libexec/java_home -v 1.7

This command returns the installation path for Java 7. Similarly, for other versions, use -v 1.8 for Java 8, -v 11 for Java 11.

Android Studio Version Differences

Different versions of Android Studio may have variations in JDK configuration locations:

• In Android Studio Arctic Fox (2020.3.1) and newer versions, the JDK location is set at: File > Settings > Build, Execution, Deployment > Build Tools > Gradle > Gradle JDK
• In Android Studio 4.2 and earlier versions, configure through: File > Project Structure > SDK Location

JDK Roles in Android Build System

Understanding the different roles of JDK in the Android build system is crucial:

Running Android Studio and Gradle: The JDK provides the Java Virtual Machine (JVM) used to run the Android Studio IDE and Gradle build tools. JetBrains Runtime (JBR) is the recommended runtime environment for Android Studio, optimized for IDE usage.

Compiling Java Source Code: The compiler within the JDK is used to compile Java source code in the project. This is closely related to compileSdkVersion, as different Android API levels require support from specific JDK versions.

Java Toolchain Configuration

To ensure build consistency, it's recommended to explicitly specify the Java toolchain version in the project's build.gradle file:

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

This configuration approach will:

• Locate a compatible JDK on the build system
• Download one if no compatible JDK exists (when a toolchain resolver is configured)
• Provide default values for sourceCompatibility and targetCompatibility

Compatibility Configuration

Additionally, configure Java compilation options in the module's build.gradle file:

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

sourceCompatibility determines the available language features during Java source code compilation, while targetCompatibility and jvmTarget determine the class format versions for generated Java bytecode and Kotlin bytecode, respectively.

Environment Variable Configuration

To ensure build environment consistency, configure the JAVA_HOME environment variable. When running Gradle in the terminal, the system searches for JVM in the following order:

1. STUDIO_JDK environment variable
2. studio.jdk directory in the Android Studio distribution
3. jbr directory (JetBrains Runtime) in the Android Studio distribution
4. JDK_HOME environment variable
5. JAVA_HOME environment variable
6. java executable in the PATH environment variable

Gradle Daemon Optimization

Gradle creates daemon processes to execute actual build tasks. As long as builds use the same JDK and Gradle version, this process can be reused. Reusing daemons reduces the time required to start a new JVM and initialize the build system. If builds are started with different JDKs or Gradle versions, additional daemons are created, consuming more CPU and memory resources.

Android Gradle Plugin Compatibility

Ensure that the selected JDK version is higher than or equal to the minimum version required by the Gradle plugins used in the project. For example, Android Gradle Plugin 8.x requires JDK 17. Attempting to run a build with an earlier JDK version will produce an error similar to:

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.

Best Practices Summary

Based on the above analysis, the following best practices are recommended:

• Always explicitly specify the Java toolchain version in build.gradle
• Ensure the Gradle JDK configuration in Android Studio points to the same JDK as the JAVA_HOME environment variable
• Select appropriate JDK versions based on the Android Gradle Plugin version used in the project
• Maintain consistency between sourceCompatibility, targetCompatibility, and jvmTarget configurations
• Regularly check and update JDK versions to meet the latest Android development requirements

By correctly configuring JDK versions, developers can not only resolve build errors but also ensure long-term project maintainability and cross-environment build consistency.