A modern programming language that makes developers happier.

kotlinlang

So, publishing a library to Sonatype. Have some local .jar dependencies that I need to include with the publication.

Have no clue how to do that and cannot find anything when searching. Anyone got ideas?

This is my gradle file which shows the jar dependencies for Android and Jvm, as well as the jar repackaging logic

<https://github.com/toxicity-io/sqlite-mc/blob/master/library/driver/build.gradle.kts>

image.png

Example: From the snapshots for the android publication you can see the `.jar` files included

*but* for the `jvm` publication, no additional `.jar` files are included

Looks like the jars are shadowed inside the .aar in the android case. It's not a publishing issue, it's about how you build your `driver-jvm-[...].jar`

You can customize it with sutff like:
```tasks.named("jvmJar").configure {
  this as Jar
  from("libs/sqlite-driver.jar)
  from("libs/sqlite-jdbc.jar)
}```

Added

```tasks.withType&lt;Jar&gt; {
    if (name != "jvmJar") return@withType
    from(jdbcRepack.jarSQLiteJDBCJvm)
    from(jdbcRepack.jarSQLDelightDriver)
}```
resulting `.jar` file includes the 2 jars. Will this work for library consumers, them being packaged this way?

I have no idea but at least it'll look like your android .aar :smile:

If those are regular dependencies, the usual way is to have them declared in the .pom/.module file and let Gradle/Maven do their magic during dependency resolution

Unfortunately, cannot do that. I'm providing a repackaged jar of `xerial/sqlite-jdbc` whereby the native binaries are compiled using `SQLite3MultipleCiphers`, so.

So if you want to shadow the usual way is to relocate using something like <https://github.com/johnrengelman/shadow>

Yeap, but the JNI interface cannot be relocated :sad-panda: lol

&gt; the JNI interface cannot be relocated
you "just" have to do it manually :see_no_evil:

You can shadow without relocation but then it will clash if someone tries to pull the same dependency

Pretty sure there is a `from()` call that "expands" the zip. Maybe zipTree or something
```tasks.withType<Jar> {
    if (name != "jvmJar") return@withType
    from(zipTree(jdbcRepack.jarSQLiteJDBCJvm))
}```

Then it will put all the .class files in your jar

If you have JNI, you should also copy the `.so` native libs too

That worked out. Different project, tests run now for both Android and Jvm using the publications