gradle · cdsap · Dec 2, 2025 · Nov 27, 2025
diff --git a/src/main/groovy/org/gradle/android/workarounds/JdkImageWorkaround.groovy b/src/main/groovy/org/gradle/android/workarounds/JdkImageWorkaround.groovy
@@ -105,16 +105,22 @@ class JdkImageWorkaround implements Workaround {
 
     private static void applyToAllAndroidVariants(Project project, Closure<?> configureVariant) {
         project.plugins.withId("com.android.application") {
-            def androidComponents = project.extensions.findByName("androidComponents")
-            def selector = androidComponents.selector()
-            androidComponents.onVariants(selector.all(), configureVariant)
+            configureAndroidComponents(project, configureVariant)
         }
 
         project.plugins.withId("com.android.library") {
-            def androidComponents = project.extensions.findByName("androidComponents")
-            def selector = androidComponents.selector()
-            androidComponents.onVariants(selector.all(), configureVariant)
+            configureAndroidComponents(project, configureVariant)
         }
+
+        project.plugins.withId("com.android.kotlin.multiplatform.library") {
+            configureAndroidComponents(project, configureVariant)
+        }
+    }
+
+    private static void configureAndroidComponents(Project project, Closure<?> configureVariant) {
+        def androidComponents = project.extensions.findByName("androidComponents")
+        def selector = androidComponents.selector()
+        androidComponents.onVariants(selector.all(), configureVariant)
     }
 
     static def applyRuntimeClasspathNormalization(Project project) {

diff --git a/src/test/groovy/org/gradle/android/JdkImageWorkaroundTest.groovy b/src/test/groovy/org/gradle/android/JdkImageWorkaroundTest.groovy
@@ -308,4 +308,72 @@ class JdkImageWorkaroundTest extends AbstractTest {
         where:
         androidVersion << TestVersions.latestAndroidVersions
     }
+
+    def "jdkImage is normalized across same vendor similar JDK versions in Kmp Android Library"() {
+        def zuluPath = System.getProperty(ZULU_PATH)
+        def zuluAltPath = System.getProperty(ZULU_ALT_PATH)
+        Assume.assumeTrue("Zulu path is not available", zuluPath != null && new File(zuluPath).exists())
+        Assume.assumeTrue("Zulu alternate path is not available", zuluAltPath != null && new File(zuluAltPath).exists())
+        Assume.assumeTrue("Android Gradle Plugin < 9", androidVersion >= VersionNumber.parse("9.0.0-alpha01"))
+
+        def gradleVersion = TestVersions.latestSupportedGradleVersionFor(androidVersion)
+
+        SimpleAndroidApp.builder(temporaryFolder.root, cacheDir)
+            .withAndroidVersion(androidVersion)
+            .withKotlinMultiplatformEnabled()
+            .withDatabindingDisabled()
+            .build()
+            .writeProject()
+
+        when:
+        BuildResult buildResult = withGradleVersion(gradleVersion.version)
+            .withProjectDir(temporaryFolder.root)
+            .withEnvironment(
+                System.getenv() +
+                ["JDK": zuluPath]
+            )
+            .withArguments(
+                "clean", "test", "assemble",
+                "--build-cache",
+                "-Porg.gradle.java.installations.auto-detect=false",
+                "-Porg.gradle.java.installations.fromEnv=JDK"
+            ).build()
+
+        then:
+        buildResult.task(':app:compileDebugJavaWithJavac').outcome == TaskOutcome.SUCCESS
+        buildResult.task(':library:compileDebugJavaWithJavac').outcome == TaskOutcome.SUCCESS
+
+        buildResult.task(':app:compileDebugUnitTestJavaWithJavac').outcome == TaskOutcome.SUCCESS
+        buildResult.task(':library:compileDebugUnitTestJavaWithJavac').outcome == TaskOutcome.SUCCESS
+
+        buildResult.task(':kmpLibrary:compileAndroidMainJavaWithJavac').outcome == TaskOutcome.SUCCESS
+
+        when:
+        buildResult = withGradleVersion(gradleVersion.version)
+            .withProjectDir(temporaryFolder.root)
+            .withEnvironment(
+                System.getenv() +
+                 ["JDK": zuluAltPath]
+            )
+            .withArguments(
+                "clean", "test", "assemble",
+                "--build-cache",
+                "-Porg.gradle.java.installations.auto-detect=false",
+                "-Porg.gradle.java.installations.fromEnv=JDK"
+            ).build()
+
+        then:
+        buildResult.task(':app:compileDebugJavaWithJavac').outcome == TaskOutcome.FROM_CACHE
+        buildResult.task(':app:compileReleaseJavaWithJavac').outcome == TaskOutcome.FROM_CACHE
+        buildResult.task(':library:compileDebugJavaWithJavac').outcome == TaskOutcome.FROM_CACHE
+        buildResult.task(':library:compileReleaseJavaWithJavac').outcome == TaskOutcome.FROM_CACHE
+
+        buildResult.task(':app:compileDebugUnitTestJavaWithJavac').outcome == TaskOutcome.FROM_CACHE
+        buildResult.task(':library:compileDebugUnitTestJavaWithJavac').outcome == TaskOutcome.FROM_CACHE
+
+        buildResult.task(':kmpLibrary:compileAndroidMainJavaWithJavac').outcome == TaskOutcome.FROM_CACHE
+
+        where:
+        androidVersion << TestVersions.latestAndroidVersions
+    }
 }
diff --git a/src/test/groovy/org/gradle/android/SimpleAndroidApp.groovy b/src/test/groovy/org/gradle/android/SimpleAndroidApp.groovy
@@ -19,8 +19,9 @@ class SimpleAndroidApp {
     private final String toolchainVersion
     private final boolean pluginsBlockEnabled
     private final boolean pluginAppliedInPluginBlock
+    private final boolean kotlinMultiplatformEnabled
 
-    private SimpleAndroidApp(File projectDir, File cacheDir, VersionNumber androidVersion, VersionNumber kotlinVersion, boolean dataBindingEnabled, boolean kotlinEnabled, boolean kaptWorkersEnabled, String toolchainVersion, boolean pluginsBlockEnabled, boolean pluginAppliedInPluginBlock) {
+    private SimpleAndroidApp(File projectDir, File cacheDir, VersionNumber androidVersion, VersionNumber kotlinVersion, boolean dataBindingEnabled, boolean kotlinEnabled, boolean kaptWorkersEnabled, String toolchainVersion, boolean pluginsBlockEnabled, boolean pluginAppliedInPluginBlock, boolean kotlinMultiplatformEnabled) {
         this.dataBindingEnabled = dataBindingEnabled
         this.projectDir = projectDir
         this.cacheDir = cacheDir
@@ -31,6 +32,7 @@ class SimpleAndroidApp {
         this.toolchainVersion = toolchainVersion
         this.pluginsBlockEnabled = pluginsBlockEnabled
         this.pluginAppliedInPluginBlock = pluginAppliedInPluginBlock
+        this.kotlinMultiplatformEnabled = kotlinMultiplatformEnabled
     }
 
     def writeProject() {
@@ -80,13 +82,15 @@ class SimpleAndroidApp {
                         classpath ('com.android.tools.build:gradle') { version { strictly '$androidVersion' } }
                         ${pluginBuildScriptClasspathConfiguration}
                         ${kotlinPluginDependencyIfEnabled}
+                        ${pluginKotlinMultiplatformIfEnabled}
                     }
                 }
                 ${pluginBlockConfiguration}
             """.stripIndent()
         if (kotlinEnabled) {
             writeKotlinClass(library, libPackage, libraryActivity)
             writeKotlinClass(app, appPackage, appActivity)
+
         }
         writeActivity(library, libPackage, libraryActivity)
 
@@ -101,6 +105,7 @@ class SimpleAndroidApp {
         file('settings.gradle') << """
                 include ':${app}'
                 include ':${library}'
+                ${addKmpLibrary}
             """.stripIndent()
 
         file("${app}/build.gradle") << subprojectConfiguration("com.android.application", appPackage) << """
@@ -125,6 +130,19 @@ class SimpleAndroidApp {
             """.stripIndent()
 
         configureAndroidSdkHome()
+
+        if (kotlinEnabled && kotlinMultiplatformEnabled) {
+            def kmpLibrary = 'kmpLibrary'
+            def kmpLibPackage = 'org.gradle.android.example.kmp.library'
+            def kmpLibraryActivity = 'KmpLibraryActivity'
+
+            file("${kmpLibrary}/build.gradle") << buildScriptKmpProject("com.android.kotlin.multiplatform.library", kmpLibPackage)
+
+            file("${kmpLibrary}/src/androidTest/AndroidManifest.xml") << CodeSnippets.getXmlEmptyManifest()
+
+            writeActivity(kmpLibrary, kmpLibPackage, kmpLibraryActivity)
+            writeKotlinClass(kmpLibPackage, kmpLibPackage, kmpLibraryActivity)
+        }
     }
 
     private String getPluginBlockConfiguration() {
@@ -167,6 +185,16 @@ class SimpleAndroidApp {
         """.stripIndent() : ""
     }
 
+    private String getPluginKotlinMultiplatformIfEnabled() {
+        return kotlinEnabled && kotlinMultiplatformEnabled? """
+            classpath "org.jetbrains.kotlin.multiplatform:org.jetbrains.kotlin.multiplatform.gradle.plugin:${kotlinVersion}"
+        """.stripIndent() : ""
+    }
+
+    private String getAddKmpLibrary() {
+        return kotlinEnabled && kotlinMultiplatformEnabled ? "include ':kmpLibrary'" : ""
+    }
+
     private subprojectConfiguration(String androidPlugin, String namespace) {
         """
             apply plugin: "$androidPlugin"
@@ -202,6 +230,54 @@ class SimpleAndroidApp {
         """.stripIndent()
     }
 
+    private buildScriptKmpProject(String androidPlugin, String namespace) {
+        """
+            apply plugin: "$androidPlugin"
+            apply plugin: "org.jetbrains.kotlin.multiplatform"
+            ${kotlinPluginsIfEnabled}
+            apply plugin: "org.gradle.android.cache-fix"
+
+            kotlin {
+               androidLibrary {
+                   namespace = "$namespace"
+                   compileSdk = 36
+                   minSdk = 24
+
+                   withJava()
+                   withHostTestBuilder {}.configure {}
+                   withDeviceTestBuilder {
+                       it.sourceSetTreeName = "test"
+                   }
+                   androidResources.enable = true
+
+               }
+
+               sourceSets {
+                   androidMain {
+                     dependencies {
+                      implementation 'joda-time:joda-time:2.7'
+                      }
+                   }
+                   androidHostTest {
+                       dependencies {
+                       }
+                   }
+                   androidDeviceTest {
+                       dependencies {
+                       }
+                   }
+               }
+            }
+
+            repositories {
+                google()
+                mavenCentral()
+            }
+
+            ${toolchainConfigurationIfEnabled}
+        """.stripIndent()
+    }
+
     private int getSdkVersion() {
         return androidVersion.major < 9 ? 33 : 36
     }
@@ -268,17 +344,19 @@ class SimpleAndroidApp {
 
     private writeActivity(String basedir, String packageName, String className) {
         String resourceName = className.toLowerCase()
-
-        file("${basedir}/src/main/java/${packageName.replaceAll('\\.', '/')}/HelloActivity.java") <<
+        String sourceSet = className == "KmpLibraryActivity" ? "androidMain" : "main"
+        file("${basedir}/src/${sourceSet}/java/${packageName.replaceAll('\\.', '/')}/HelloActivity.java") <<
             CodeSnippets.getJavaActivity(packageName, resourceName)
+        println(className )
+        println("${basedir}/src/${sourceSet}/java")
 
         file("${basedir}/src/test/java/${packageName.replaceAll('\\.', '/')}/JavaUserTest.java") <<
             CodeSnippets.getJavaSimpleTest(packageName)
 
         file("${basedir}/src/androidTest/java/${packageName.replaceAll('\\.', '/')}/JavaUserAndroidTest.java") <<
             CodeSnippets.getJavaAndroidTest(packageName)
 
-        file("${basedir}/src/main/res/layout/${resourceName}_layout.xml") << CodeSnippets.getXmlGenericLayout()
+        file("${basedir}/src/${sourceSet}/res/layout/${resourceName}_layout.xml") << CodeSnippets.getXmlGenericLayout()
 
         file("${basedir}/src/main/rs/${resourceName}.rs") << CodeSnippets.getRs()
     }
@@ -316,6 +394,7 @@ class SimpleAndroidApp {
         boolean kaptWorkersEnabled = true
         boolean pluginsBlockEnabled = false
         boolean pluginAppliedInPluginBlock = false
+        boolean kotlinMultiplatformEnabled = false
 
         VersionNumber androidVersion = TestVersions.latestAndroidVersionForCurrentJDK()
         VersionNumber kotlinVersion = TestVersions.latestSupportedKotlinVersion()
@@ -380,8 +459,13 @@ class SimpleAndroidApp {
             return this
         }
 
+        Builder withKotlinMultiplatformEnabled() {
+            this.kotlinMultiplatformEnabled = true
+            return this
+        }
+
         SimpleAndroidApp build() {
-            return new SimpleAndroidApp(projectDir, cacheDir, androidVersion, kotlinVersion, dataBindingEnabled, kotlinEnabled, kaptWorkersEnabled, toolchainVersion, pluginsBlockEnabled, pluginAppliedInPluginBlock)
+            return new SimpleAndroidApp(projectDir, cacheDir, androidVersion, kotlinVersion, dataBindingEnabled, kotlinEnabled, kaptWorkersEnabled, toolchainVersion, pluginsBlockEnabled, pluginAppliedInPluginBlock, kotlinMultiplatformEnabled)
         }
     }
 }