Hey how can I split configuration of a plugin through multiple build.gradle.kts scripts? I have to configure different types and want to have a file that simply exports that config for a certain type then include all the subscripts in the build.gradle.kts Is the only way to do this with buildSrc or can I use apply from?

¨

I want to create a precompiled build script plugin for an Android app but I'm getting an error in the plug-in,

android

is not defined. Looks like I'm missing some dependencies possibly, does anybody have an example to follow or some hints on what the issue might be? Details in thread.

following on from the message above, I have a versions catalog where I define the dependencies - is it possible to use that in the

buildSrc/build.gradle.kts

? Details in thread

Is there a replacement that doesn’t use the deprecated

withConvention

?

Why are there so many ways to set Java & Kotlin versions? Which is the right one for a JVM project? And why do I keep getting this message?

Language version 1.4 is deprecated and its support will be removed in a future version of Kotlin

I’m not sure if this is the right channel, but I recently upgraded a library I own from Kotlin 1.5.30 to 1.6.10, along with the kotlin-gradle plugin, and am using JVM 11 and Gradle 7.0.2. Now I have a consumer app of this library which is now failing to compile because it’s not recognizing a bunch of interface/companion object properties. The consumer app uses Kotlin 1.6.10 and the same gradle plugin and JVM. Everything was working with 1.5.30 and the only thing I changed was the Kotlin version. Here’s an example: In the library, I have this object:

object Scopes {
  fun serial(): CoroutineScope = CoroutineScope(...)
}

In the consumer app of the library, I’m getting this new error:

Scopes.serial() -> Unresolved reference: serial

Java 8 Bytecode from consumer app:

public final class Scopes {
    @NotNull
    public static final Scopes INSTANCE = new Scopes();

However, I call Scopes.INSTANCE.serial() it works. Additionally, I’m getting errors with accessor properties in interfaces not being recognized in the consumer app, even though the decompiled java bytecode says it’s there. Is there an additional compiler configuration I’m missing?

I have a Kotlin Multiplatform Mobile project and I am trying to write custom lint checks for android. I created a lint check module with the custom checks and not I am trying to add the module to the KMM library project module. The examples I have seen are just for normal android apps and using Groovy for their gradle files where I am using kotlin dsl so I am not sure what to do here but I tried to add the

lintPublish

to the

androidMain

dependencies like this

val androidMain by getting {
            dependencies {
                lintPublish(project(":lint"))
                implementation("androidx.core:core-ktx:1.7.0")
                implementation("io.ktor:ktor-client-android:1.6.7")
                implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.0")
            }
        }

but the kotlin dsl does not recognize

lintPublish

. The exact error is

Unresolved reference. None of the following candidates is applicable because of receiver type mismatch:

What am I doing wrong, do I place the lintPublish somewhere else? Does KMM work with custom lint checks?

Hey guys, been looking how to make a fat jar from kotlin, was looking at this although its not working (im using gradle 7+) any suggestions?

Hello, I have a problem with JVM Multiplatform and Application plugins, I can not run my main

plugins {
    kotlin("multiplatform")
    application
}

application {
    mainClass.set("io.github.jervnorsk.aden.server.Main")
}

kotlin {
    jvm {
        testRuns["test"].executionTask.configure {
            useJUnitPlatform()
            testLogging {
                events = setOf(
                    org.gradle.api.tasks.testing.logging.TestLogEvent.FAILED,
                    org.gradle.api.tasks.testing.logging.TestLogEvent.PASSED
                )
                exceptionFormat = org.gradle.api.tasks.testing.logging.TestExceptionFormat.FULL

                showExceptions = true
                showStandardStreams = true
            }
        }

    }
    sourceSets {
        val commonMain by getting {
            dependencies {}
        }
        val commonTest by getting {
            dependencies {
                implementation(kotlin("test"))
            }
        }
        val jvmMain by getting {
            dependencies {
                implementation("io.ktor:ktor-server-core:${extra["ktor.version"]}")
                implementation("io.ktor:ktor-server-netty:${extra["ktor.version"]}")
                implementation("ch.qos.logback:logback-classic:1.2.5")
            }
        }
    }
}

my build.gradle file contains the folowing section:

compileKotlin {
    kotlinOptions {
        jvmTarget = "14"
        allWarningsAsErrors = true
        freeCompilerArgs += [

                "-Xopt-in=kotlinx.coroutines.ExperimentalCoroutinesApi",
                "-Xopt-in=kotlin.RequiresOptIn",
                "-Xopt-in=kotlinx.coroutines.ObsoleteCoroutinesApi"]
    }
}

However since kotlin 1.6.0 the -Xopt-in flag shoud be replaced with -opt-in. The problem is that I often switch kotlin version (and then I remove/add the X character). Is there a way to have one gradle file that works for both kotlin 1.5 and kotlin 1.6?

Just putting it out there in case anyone else is seeing this: Taking my project from Kotlin

1.6.10

to

1.6.20

causes this

StackOverflowError

when Gradle syncing the project. Same result on Gradle

7.4.2

and

7.4.1

Hi, do we know what all network related is Intellij IDE gradle sync doing? It hangs why I’m connected to VPN, and I need to allow this traffic

Hey, I want to implement a custom Plugin which should also apply the kotlin plugin. I am using

KotlinPlatformJvmPlugin

, which works, but I am getting a deprecated info. What is the updated plugin class?

is it possible to define variables in

gradle.properties

(like coroutinesVersion=1.6.1 or kotlinVersion=1.6.20) and then inside build.gradle.kts access it somehow?

plugins {
   kotlin("multiplatform").version(kotlinVersion).apply(false)

val commonMain by getting {
   dependencies {
      api("org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutinesVersion")

Alternatively, what is the consensus on using version catalogues (define a catalogue in the root and then keep all the module depenendency versions in sync like this) https://docs.gradle.org/current/userguide/platforms.html

using version catalogs, how do you check for dependency updates ?

I'm using a Gradle composite build for my custom plugins. I'm also using the version catalog for my dependencies, which I'm also using in my composite build. Every time the composite build module is rebuilt I get the following error:

Unresolved reference: versionCatalogs

However everything works fine besides this error. I can build my (android) app without any other problems. The CLI never reports this error. Someone has an idea how to solve this? This is my

settings.gradle.kts

file within the composite build:

dependencyResolutionManagement {
    versionCatalogs {
        create("libs") {
            from(files("../gradle/libs.versions.toml"))
        }
    }
}

I'm using the latest stable Gradle Version (7.4.2)

Hello, how can I use `Gadle`’s new

jacoco-report-aggregation

for Android projects. Google around a bit and check

Gradle

documentation but couldn’t adapt it for my project. Can somebody shed some light on this? Thank you!

In a gradle plugin, how do I access all native sourcesets in a given project?

is it possible to share versionCatalogs between projects? ProjectA contains a VersionCatalog

dependencyResolutionManagement {
   versionCatalogs {
      create("blah") {

         val coroutinesVersion = "1.6.1"
         library("kotlinx-coroutines-core", "org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutinesVersion")
         library("kotlinx-coroutines-jdk8", "org.jetbrains.kotlinx:kotlinx-coroutines-jdk8:$coroutinesVersion")

and inside ProjectA, any module that needs coroutines, just

implement(blah.kotlinx.coroutines.core)

now ProjectB's settings.gradle.kts contains

// blah
includeBuild("../blah-framework")

and I can include modules like this:

implementation("io.blah:blah-module-1")
implementation("io.blah:blah-module-2")

Now in projectB, I want to include coroutines but I want to lock the version to whatever the version is in blah-framework and just include it

implementation(blah.kotlinx.coroutines.core)

is this possible with versionCatalogs?

Ever since my upgrade to 2022.1 (Ultimate Edition) I am seeing “Invalid value: -1” errors whenever I try to run a gradle task from IntelliJ. For example, let’s say I try to run the

assemble

task, it appears that the code compiles successfully, but then as a very last step IntelliJ fails with “Invalid value: -1". Kotlin version: 1.6.20 Gradle version: 7.4.2 I don’t have any issues running the

assemble

task from the command line, so I know it is something to do with IntelliJ. Anyone else seeing this? ** Not a contribution

Hi, I have a very weird problem, when launching a GitHub Action, gradle doesn't find a task that I can find myself locally,

publishToSonatype

, here's my workflow file and here's the result I'm just trying to publish all my modules to sonatype at once using a github action and it's very very hard. When using

./gradlew tasks

the task is there

Is anything known about when gradle will support plugins written in more recent kotlin versions? It's very annoying to be limited to kotlin 1.5.31 throughout my entire project because gradle doesn't use a newer version and as such the plugin subproject needs to use 1.5.31

Looks like Kotlin 1.6.20 broke dependency resolution of MPP with composite builds… again 🙁 But this time it’s not just in the IDE. Even Gradle cannot find some symbols anymore 😮 Anyone else ran into the same issue?

Where would you define your project's Gradle convention plugin? 1️⃣ in buildSrc 2️⃣ included build 3️⃣ Elsewhere I just discovered from that article that buildSrc and included builds both have performance issues...

Hi all - New to gradle. I’m sure I’m doing something silly, but I’m trying to add a jar building capability to my gradle file. But I’m getting an error:

Expression 'jar' cannot be invoked as a function. The function 'invoke()' is not found

. I already added the

java

plugin in the

plugins

function. Would any one be able to provide some guidance? Thanks!

import org.jetbrains.kotlin.gradle.tasks.KotlinCompile

plugins {
    kotlin("jvm") version "1.6.21"
    java
    application
}

group = "me.talha"
version = "1.0-SNAPSHOT"

repositories {
    mavenCentral()
}

dependencies {
    testImplementation(kotlin("test"))
}

tasks.test {
    useJUnitPlatform()
}

tasks.withType<KotlinCompile>() {
    kotlinOptions.jvmTarget = "11"
}

application {
    mainClass.set("MainKt")
}

jar {
    manifest {
        attributes 'Main-Class': 'MainKt'
    }
}

Hi, what is the best way to declare dependencies between

buildSrc

and version catalogs ?

Currently I'm trying out multi module with kotlin and gradle. Also trying to implement gitlab cicd pipeline. But how can I have al the test results of the multiple modules show in gitlab? I tried a plugin (test report aggregation) but that wasn't the right plugin because it doesn't aggregate the xml files but it does the html ones. Does anyone have an idea how I can show all my test result in gitlab after a test run?

Hi everyone, I am trying to do some custom logic for each build variant. I am trying to use the new

onVariants

API, but it is not working, throwing

groovy.lang.MissingMethodException

. The below snippet contains the code which I have added to my

app/build.gradle

-

plugins {
    //...
}

android {
    //...
}

androidComponents {
    onVariants { variant ->

    }
}