CODEWITHSUNDEEP
gradlekotlinkotlin-multiplatform
Steven Jeuris
Steven Jeuris

Reputation: 19100

How to add project dependencies to specific platform targets created by the `kotlin-multiplatform` plugin?

Previously, building multiplatform projects using Gradle relied on separate Gradle plugins per targeted platform: kotlin-platform-common, kotlin-platform-js, and kotlin-platform-jvm.

Starting from Kotlin 1.3, this is now unified using one kotlin-multiplatform plugin. The current documentation specifies how to set up multiplatform projects using this approach.

However, in my project I have multiple multiplatform projects with some dependencies between them. With the old multiplatform configuration, each different platform is a separate module and adding dependencies between projects required adding project references in each platform-specific module to corresponding modules in the other project: e.g., project(':some-library:some-library-js') to add a dependency to the JS module from within another JS module.

While migrating to the new multiplatform configuration, I now need to add a dependency from a project configured using the old configuration method to a project configured using the new kotlin-multiplatform plugin.

Given that platform-specific modules are now specified and managed by the new plugin, how do I go about this?

Upvotes: 2

Views: 1780

Answers (2)

Steven Jeuris
Steven Jeuris

Reputation: 19100

I'm not certain whether the following approach is the recommended method, or I overlooked any potential issues, but my projects compile and all tests pass.

In Gradle, you can add dependencies to specific project configurations:

dependencies {
    implementation project(path: ':some-library', configuration: 'configName')
}

By trial and error I figured out that specifying the following configuration dependencies per platform module type works:

  • common: configuration: 'archives'. Without this, Gradle configuration fails as code dependencies are not found.

Without the following, compilation fails:

  • jvm: configuration: 'jvmDefault'
  • js: configuration: 'jsDefault'

For example, for the JS module as specified in the question:

dependencies {
    implementation project(path: ':some-library', configuration: 'jsDefault')
}

Upvotes: 3

hotkey
hotkey

Reputation: 147981

Basically, you don't need to specify the platform in project-to-project dependencies involving Kotlin Muiltiplatform projects. The Kotlin plugin sets up dependency resolution in a way that Gradle will choose the appropriate target's artifacts automatically.

So, for example, in a Kotlin/JVM single-target project, you can just use a project("...") dependency on a Multiplatform project:

dependencies {
    implementation(project(":multiplatform-library")
}

If :multiplatform-library has a JVM target, this dependency will get resolved to the JVM target's artifact. Otherwise, you will encounter a dependency resolution failure with candidate configurartions listed.

This is described in the Kotlin reference, Building Multiplatform Projects with Gradle – Adding Dependencies, but is applicable to single-platform projects, too:

<...> a project('...') dependency on another multiplatform project is resolved to an appropriate target automatically. It is enough to specify a single project('...') dependency in a source set's dependencies, and the compilations that include the source set will receive a corresponding platform-specific artifact of that project, given that it has a compatible target.

If this does not happen for you, please post the specific dependency resolution failure log, or file an issue at https://kotl.in/issue.

Upvotes: 1

Related Questions