IssueTracker

Thanks a lot for the nice reproducible project!

Issue

• Expected behavior: androidx.compose.runtime:runtime-android:1.6.3 (for Android) is packaged in the APK

• Actual behavior: androidx.compose.runtime:runtime-desktop:1.6.3 (for JVM) is packaged in the APK

Root cause

androidx.compose.runtime:runtime:1.6.3 provides 2 variants runtime-android and runtime-desktop with the following attributes:

During a build, which one of these two variants is selected depends on the query from the consumer.

1. If KGP is not applied in app, org.jetbrains.kotlin.platform.type is not requested in the query, therefore the 2 variants seem equivalent. However, Gradle decides to select the runtime-desktop variant, probably because runtime-desktop defines org.gradle.libraryelements = jar whereas runtime-android does not define that attribute:

AGP-Library-Bug$ ./gradlew :app:dependencyInsight --dependency androidx.compose.runtime:runtime-desktop:1.6.3 --configuration debugRuntimeClasspath

> Task :app:dependencyInsight
androidx.compose.runtime:runtime-desktop:1.6.3
  Variant desktopRuntimeElements-published:
    | Attribute Name                                  | Provided     | Requested    |
    |-------------------------------------------------|--------------|--------------|
    | org.gradle.libraryelements                      | jar          |              |
    | org.jetbrains.kotlin.platform.type              | jvm          |              |
    | org.gradle.category                             | library      | library      |
    | org.gradle.usage                                | java-runtime | java-runtime |
    | com.android.build.api.attributes.AgpVersionAttr |              | 8.2.2        |
    | com.android.build.api.attributes.BuildTypeAttr  |              | debug        |
    | org.gradle.jvm.environment                      |              | android      |

2. If KGP is applied in app, org.jetbrains.kotlin.platform.type = androidJvm is now requested in the query, therefore runtime-android is selected, as expected:

> Task :app:dependencyInsight
androidx.compose.runtime:runtime-android:1.6.3
  Variant releaseRuntimeElements-published:
    | Attribute Name                                  | Provided     | Requested    |
    |-------------------------------------------------|--------------|--------------|
    | org.gradle.category                             | library      | library      |
    | org.gradle.usage                                | java-runtime | java-runtime |
    | org.jetbrains.kotlin.platform.type              | androidJvm   | androidJvm   | => THIS ATTRIBUTE IS REQUESTED IF KGP IS APPLIED
    | com.android.build.api.attributes.AgpVersionAttr |              | 8.2.2        |
    | com.android.build.api.attributes.BuildTypeAttr  |              | debug        |
    | org.gradle.jvm.environment                      |              | android      |

Workaround

To work around this issue, the users will need to apply KGP in app (or in any Java module that has this issue).

Fix

The fix is TBD.

Thanks for the detailed investigation! Besides applying the Kotlin plugin everywhere (we still have a lot of legacy java modules with no kotlin code), trying this on the same project's app/build.gradle seems to work:

KotlinPlatformType.setupAttributesMatchingStrategy(project.dependencies.attributesSchema)
androidComponents.onVariants { variant ->
    variant.components
        .flatMap { listOfNotNull(it.runtimeConfiguration, it.compileConfiguration) }
        .forEach { configuration ->
            configuration.attributes.apply {
                attribute(KotlinPlatformType.attribute, KotlinPlatformType.androidJvm)
            }
        }
}

Though I'm not certain if will miss anything or cause other issues.

We should add org.gradle.jvm.environment=android when publishing -android variants of KMP libs. This attribute is requested by AGP since 4.0+ IIRC.

The issue at hand is that projects that use compose are pulled in by an app project that does not apply Kotlin Gradle Plugin. The workaround is to add a Kotlin Gradle Plugin to the Gradle project that builds the app.

What I suggested in #6 is a workaround, we'll see how we can fix the artifacts to resolve as expected by simply using AGP without KGP.

Yes, there is a change request with a fix - it is in a process of being reviewed.

This will be fixed in AGP 8.5.0-alpha04 and also will be backported to 8.4.0 RC2 and stable

It breaks on the consumer side, not the publishing side.

That is correct. Older AGP versions with Kotlin Gradle Plugin applied did not set enough attributes when resolving the dependencies resulting in the wrong platform being picked up.

The only way for this to work again would be for compose to stop publishing -desktop platform of compose and we don't think we are willing to do that.

How much control do you have over your consumers? You could potentially create a Gradle plugin that tweaks AGP configurations in older versions.

Yes KGP should just work.

Indeed, 8.3 is the latest stable version at this point. 8.4 (and the corresponding IDE Jellyfish) is still in beta stage as you mentioned. The fix in AGP will go out in 8.4 RC2 (it missed the boat for RC1) and subsequently stable.

As comment #3 mentioned, you should be able to manually force the variant by explicitly applying the variant selection attribute:

KotlinPlatformType.setupAttributesMatchingStrategy(project.dependencies.attributesSchema)
androidComponents.onVariants { variant ->
    variant.components
        .flatMap { listOfNotNull(it.runtimeConfiguration, it.compileConfiguration) }
        .forEach { configuration ->
            configuration.attributes.apply {
                attribute(KotlinPlatformType.attribute, KotlinPlatformType.androidJvm)
            }
        }
}

Gradle's variant resolution is unfortunately very difficult to understand, but essentially this tells gradle to prefer the android artifacts whenever they're available.

As AGP we can't do much about this fact that people can't upgrade to the latest version. Essentially the issue stems from a discrepancy in the way KGP publishes multiplatform libraries and the way AGP consumes them. This problem is now fixed and in AGP 8.4 RC2 (and 8.5 canary 4). From KGP side the problem is also fixed - please refer to https://youtrack.jetbrains.com/issue/KT-49919/Introduce-the-org.gradle.jvm.environment-attribute-on-JVM-and-Android-published-variants-both-for-MPP-and-non-MPP-libraries for more context.

Additionally, if you are a library developer and want to target android only you could consider not depending on androidx.compose.runtime:runtime (which exposes -android and -desktop variants) but directly depend on the androidx.compose.runtime:runtime-android (https://maven.google.com/web/index.html?#androidx.compose.runtime:runtime-android) artifact - I think this is should work - feel free to correct me if not.

Additionally, if you are a library developer and want to target android only you could consider not depending on androidx.compose.runtime:runtime (which exposes -android and -desktop variants) but directly depend on the androidx.compose.runtime:runtime-android (https://maven.google.com/web/index.html?#androidx.compose.runtime:runtime-android) artifact - I think this is should work - feel free to correct me if not.

it does not really work that way as each -android variant will pull in root non-android ones.

A postmortem task was automatically filed as a child item to this bug.

Thank you for your patience while our engineering team worked to resolve this issue. A fix for this issue is now available in:

• Android Studio Jellyfish | 2023.3.1
• Android Gradle Plugin 8.4.0

We encourage you to try the latest update.

If you notice further issues or have questions, please file a new bug report.

Thank you for taking the time to submit feedback — we really appreciate it!

Help

Help