How to set compileJava' task ( 11) and 'compileKotlin' task (1.8) jvm target compatibility to the same Java version in build.gradle.kts?

Question

Build.gradle.kts

buildscript {
    repositories {
        google()
        mavenCentral()
        gradlePluginPortal()
    }
    dependencies {
        classpath ("com.android.tools.build:gradle:7.0.2")
        classpath ("org.jetbrains.kotlin:kotlin-gradle-plugin:1.5.30")
        classpath("gradle.plugin.com.github.spotbugs.snom:spotbugs-gradle-plugin:${Versions.spotbugsGradlePluginVersion}")
        classpath("se.bjurr.violations:violations-gradle-plugin:${Versions.violationsVersion}")

    }
}
//android {
//    compileOptions {
//        sourceCompatibility = JavaVersion.VERSION_11
//                targetCompatibility = JavaVersion.VERSION_11
//    }
//
//    kotlinOptions {
//        jvmTarget = JavaVersion.VERSION_11.toString()
//    }
//}
plugins {
    `maven-publish`
    `java-gradle-plugin`
    `kotlin-dsl`
    id ("io.gitlab.arturbosch.detekt") version ("1.18.1")
}
repositories {
    google()
    mavenCentral()
    gradlePluginPortal()
}

dependencies {
    compileOnly(gradleApi())
    testImplementation(gradleTestKit())
    testImplementation("junit:junit:${Versions.jUnitVersion}")
}
val generatedSources = tasks.register<GenerateVersionsFileTask>("generateSources")

I get the following error:

ERROR : 'compileJava' task (current target is 11) and 'compileKotlin' task (current target is 1.8) jvm target compatibility should be set to the same Java version.

When I uncomment android {}, I get:

Error : Script compilation errors:

 Line 15: android {
           ^ Unresolved reference: android

Answer 1

We also need to pay attention to the version that the error is showing. In my case it was :

Caused by: org.gradle.api.GradleException: 'compileDebugJavaWithJavac' task (current target is 1.8) and 'compileDebugKotlin' task (current target is 17) jvm target compatibility should be set to the same Java version.

Which means,the Android Studio IDE is using 17 (You can find it in File Menu->Project Structure->SDK Location->JDK location)

And You are using 1.8 in your gradle files.

So you need to change

compileOptions {
    sourceCompatibility JavaVersion.VERSION_1_8
    targetCompatibility JavaVersion.VERSION_1_8
}

and

kotlinOptions {
    jvmTarget = '1.8'
}

to

compileOptions {
    sourceCompatibility JavaVersion.VERSION_17
    targetCompatibility JavaVersion.VERSION_17
}

and

kotlinOptions {
    jvmTarget = '17'
}

Note that

since the error showed 17, I have also switched to 17.

This happened when I upgraded gradle to 8.0.

Beware of release issues. Kindly take a backup before doing the procedure. May face issues in release aab.

Make sure to check the release apk after this procedure is done, because R8 expects things like this

Answer 2

You can set java version for java with

java {
    sourceCompatibility = JavaVersion.VERSION_11
    targetCompatibility = JavaVersion.VERSION_11
}

or alternatively:

java {
    toolchain.languageVersion.set(JavaLanguageVersion.of(11))
}

and for kotlin with:

tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile>().configureEach {
    kotlinOptions {
        jvmTarget = "11"
    }
}

All samples are in gradle kotlin dsl.

Answer 3

@Marian's answer didn't quite help me.

I end up setting the following in the app build.gradle

android {
...
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_11
        targetCompatibility JavaVersion.VERSION_11
    }

    kotlinOptions {
        jvmTarget=11
    }
...
}

Answer 4

In order to have the 'same version of Java' in both 'Java and Kotlin',
just modify your build.gradle file like this (example given for Java 11):

apply plugin: 'com.android.application'
apply plugin: 'kotlin-android'
...
android {
    ...
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_11
        targetCompatibility JavaVersion.VERSION_11
    }

    // New syntax (credit goes to ʍѳђઽ૯ท in comment)
    kotlin {
        jvmToolchain(11)
    }
/*
    FYI: Old syntax:
    kotlin {
        jvmToolchain {
            languageVersion.set(JavaLanguageVersion.of("11"))
        }
    }
    FYI: Deprecated syntax:
    kotlinOptions {
        jvmTarget = "11"
    }
*/
    ...
}

My configuration:

Gradle:

• Android Gradle Plugin: com.android.tools.build:gradle:7.4.1
• Gradle: 7.5 (as of ./gradle/wrapper/gradle-wrapper.properties)

Kotlin:

• Android Kotlin Plugin: 221 ( 221-1.8.0-release-for-android-studio-AS5591.52 )
  (see https://kotlinlang.org/docs/whatsnew18.html#install-kotlin-1-8-0 )
• Kotlin Gradle Plugin: org.jetbrains.kotlin:kotlin-gradle-plugin:1.8.0

About new syntax:
See New method for JVM toolchain configuration

NB:
More information about Kotlin configuration regarding that matter is available here: https://blog.jetbrains.com/kotlin/2021/11/gradle-jvm-toolchain-support-in-the-kotlin-plugin/

Answer 5

I had the same problem after update the Android Studio to Flamingo version, this is my new configs in the build.gradle

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

Answer 6

This worked nicely for me:

kotlin {
  jvmToolchain {
    languageVersion.set(JavaLanguageVersion.of("11"))
  }
}

That way I only need to set it once.

Answer 7

I tried with the following code first for all modules

compileOptions {
    sourceCompatibility = '1.8'
    targetCompatibility = '1.8'
}
kotlinOptions {
    jvmTarget = '1.8'
}

And after adding the following line into gradle.properties solved the issue.

kotlin.jvm.target.validation.mode = IGNORE

Answer 8

If anyone keeps getting warnings about a java compilation task being set to java 1.8 you can add this to the gradle script:

afterEvaluate {
    tasks.withType<JavaCompile>().configureEach {
        sourceCompatibility = JavaVersion.VERSION_11.toString()
        targetCompatibility = JavaVersion.VERSION_11.toString()
    }
}

I was getting warnings on some java compile tasks on AS and this solved it for me.

Answer 9

allprojects {
    tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile>().configureEach {
        kotlinOptions {
            jvmTarget = JavaVersion.VERSION_1_8.toString()
        }
    }
}

by including this task in your build.gradle , tells the compiler to use the JavaVersion = 1.8 in your project.

Answer 10

Surprisingly the culprit is very simple. You need to declare your KotlinCompile task before JavaCompile. Like this

tasks {

    withType<KotlinCompile> {
    
        kotlinOptions {
            freeCompilerArgs = listOf(
                "-Xextended-compiler-checks",
                "-Xinline-classes",
                "-Xjsr305=strict",
                "-Xjvm-default=all",
                "-Xskip-prerelease-check",
            )
            apiVersion = "1.8"
            languageVersion = "1.8"
            jvmTarget = "11"
        }
    }
    
    withType<JavaCompile> {
        sourceCompatibility = "11"
        targetCompatibility = "11"
    }
}

Answer 11

Marian's solution (see above) needs to be applied, but you may still see the same message as a warning especially if you run "gradle build" from a command line. I think if you "synch" with gradle from Android Studio, you might not see the warning message. If you still see the message after properly applying Marian's solution, it's apparently a bogus warning message. My understanding is that the bogus warning message goes away once you upgrade to using kotlin 1.6+. You can disable this bogus warning by adding the following to your gradle.properties file.

kotlin.jvm.target.validation.mode = IGNORE

I'm not recommending the use of the above, but I it certainly solves the issue of seeing the bogus warning message. If you do use it, remember to remove it when it's no longer needed.

The problem for most of us is that we can't upgrade to kotlin 1.6.21 at this time. In order to upgrade to kotlin 1.6.21 you need to upgrade to android gradle 7.4. To upgrade to android gradle 7.4 you need an Android Studio version greater than Dolphin | 2021.3.1, so you would have to use one of the preview versions of Android Studio to do that at this time.

for compatibility information, see https://developer.android.com/studio/releases/gradle-plugin and https://developer.android.com/studio/releases#android_gradle_plugin_and_android_studio_compatibility

Answer 12

I had experienced the same situation and tried different variations mentioned above. The strange behavior that I was having where the project built successfully on the first attempt, but the same error resurfaced when trying to build it again.

Fortunately, I found a workaround that resolved the issue. By reverting back the Gradle version from 8.0 to 7.5, the problem was resolved, and I was able to build the project without any further errors.

Answer 13

This solution worked for me:

Just replace the statement (or similar to this):

kotlinOptions {
    jvmTarget = JavaVersion.VERSION_1_8.toString() 
}

with

kotlinOptions {
    jvmTarget = "1.8"
}

in all the module level build.gradle files and then sync gradle.

Hope this works. Happy Coding...!

Answer 14

I fixed this issue by using the same Java Version:

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

Answer 15

I solved this problem by updating the configuration in the gradle.properties file.

change

distributionUrl=https\://services.gradle.org/distributions/gradle-8.0-bin.zip

to

distributionUrl=https\://services.gradle.org/distributions/gradle-7.5-bin.zip

Answer 16

One of the very similar error can be this.. Execution failed for task ':app:kaptGenerateStubsDebugKotlin'.

'compileDebugJavaWithJavac' task (current target is 1.8) and 'kaptGenerateStubsDebugKotlin' task (current target is 17) jvm target compatibility should be set to the same Java version.

First, I would ask you to go to this path in Android Studio and check what Gradle JDK versions you are using... Simply Goto ->File->Settings->Build,Execution,Development->Build Tools->Gradle Now, see inside Gradle SDK, what version is selected.

Now to fix the error open the 'build.gradle' file for your 'app module'. And to fix it, make sure to check if you have equal java version at two blocks in your 'build.gradle' . The first one is inside the 'compileOptions' , make sure the two lines have similar java versions as you have used in Gradle SDK (checked above),

compileOptions {
    sourceCompatibility JavaVersion.VERSION_11
    targetCompatibility JavaVersion.VERSION_11
}

The second block to be checked is 'kotlinOptions', check the Java version here too,

kotlinOptions {
    jvmTarget = '11'
}

And hopefully, this will solve the error.

Answer 17

Pretty much all the answers are at small variations to each other, mine too.

    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }
    kotlin {
        jvmToolchain(8)
    }

This worked for me. Looks like tool chain defaults to different value else where, this overrides to match compile options and resolves the issue.

Answer 18

For anyone who did everything but still struggling with this problem, try to downgrade your gradle version. In my case I changed 8.0 to 7.5 and it helped.

Answer 19

1. Remove package from the manifest tag in AndroidManifesty.xml
2. add the command below into project's gradle.properties:

kotlin.jvm.target.validation.mode = IGNORE 3. make sure the kotlinOptions has been set next to compileOptions: compileOptions { sourceCompatibility JavaVersion.VERSION_1_8 targetCompatibility JavaVersion.VERSION_1_8 } kotlinOptions { jvmTarget = '1.8' }