Update dependencies and simplify codebase

build.gradle.kts

@@ -1,40 +1,27 @@
 plugins {
-    kotlin("jvm") version "1.7.20"
-    id("java-gradle-plugin")
-    id("maven-publish")
+    `kotlin-dsl`
+    `maven-publish`
 }
 
 group = "com.aliucord"
 
-java {
-    sourceCompatibility = JavaVersion.VERSION_11
-    targetCompatibility = JavaVersion.VERSION_11
-}
-
-repositories {
-    mavenCentral()
-    google()
-    maven("https://jitpack.io")
-    maven("https://maven.aliucord.com/snapshots")
+kotlin {
+    jvmToolchain(17)
 }
 
 dependencies {
-    implementation(kotlin("stdlib", kotlin.coreLibrariesVersion))
-    compileOnly(gradleApi())
-
-    compileOnly("com.google.guava:guava:30.1.1-jre")
-    compileOnly("com.android.tools:sdk-common:31.0.0")
-    compileOnly("com.android.tools.build:gradle:7.0.4")
+    compileOnly(libs.android.gradle)
+    compileOnly(libs.android.sdk)
 
-    implementation("com.github.Aliucord.dex2jar:dex-translator:808b91d679")
-    implementation("com.aliucord.jadx:jadx-core:1.4.5-SNAPSHOT")
-    implementation("com.aliucord.jadx:jadx-dex-input:1.4.5-SNAPSHOT")
-    implementation("com.aliucord:jadb:1.2.1-SNAPSHOT")
+    implementation(libs.dex2jar)
+    implementation(libs.jadx.core)
+    implementation(libs.jadx.dexInput)
+    implementation(libs.jadb)
 }
 
 gradlePlugin {
     plugins {
-        create("com.aliucord.gradle") {
+        create("aliucord-plugin") {
             id = "com.aliucord.gradle"
             implementationClass = "com.aliucord.gradle.AliucordPlugin"
         }

gradle/libs.versions.toml

@@ -0,0 +1,14 @@
+[versions]
+agp = "8.8.0"
+sdk = "31.0.0"
+dex2jar = "808b91d679"
+jadx = "1.4.5-SNAPSHOT"
+jadb = "1.2.1-SNAPSHOT"
+
+[libraries]
+android-gradle = { module = "com.android.tools.build:gradle", version.ref = "agp" }
+android-sdk = { module = "com.android.tools:sdk-common", version.ref = "sdk" }
+dex2jar = { module = "com.github.Aliucord.dex2jar:dex-translator", version.ref = "dex2jar" }
+jadx-core = { module = "com.aliucord.jadx:jadx-core", version.ref = "jadx" }
+jadx-dexInput = { module = "com.aliucord.jadx:jadx-dex-input", version.ref = "jadx" }
+jadb = { module = "com.aliucord:jadb", version.ref = "jadb" }

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 #Mon May 01 00:29:28 CEST 2023
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.6.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.12.1-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

settings.gradle.kts

@@ -1 +1,17 @@
+pluginManagement {
+    repositories {
+        google()
+        gradlePluginPortal()
+    }
+}
+
+dependencyResolutionManagement {
+    repositories {
+        mavenCentral()
+        google()
+        maven("https://jitpack.io")
+        maven("https://maven.aliucord.com/snapshots")
+    }
+}
+
 rootProject.name = "gradle"

src/main/kotlin/com/aliucord/gradle/configuration/Configurations.kt

@@ -22,7 +22,7 @@ fun registerConfigurations(project: Project) {
 
     for (provider in providers) {
         project.configurations.register(provider.name) {
-            it.isTransitive = false
+            isTransitive = false
         }
     }
 

src/main/kotlin/com/aliucord/gradle/task/CompileDexTask.kt

@@ -23,7 +23,6 @@ import com.android.builder.dexing.ClassFileInputs
 import com.android.builder.dexing.DexArchiveBuilder
 import com.android.builder.dexing.DexParameters
 import com.android.builder.dexing.r8.ClassFileProviderFactory
-import com.google.common.io.Closer
 import org.gradle.api.DefaultTask
 import org.gradle.api.file.ConfigurableFileCollection
 import org.gradle.api.file.RegularFileProperty
@@ -48,72 +47,74 @@ abstract class CompileDexTask : DefaultTask() {
     @get:OutputFile
     abstract val pluginClassFile: RegularFileProperty
 
-    @Suppress("UnstableApiUsage")
     @TaskAction
     fun compileDex() {
         val android = project.extensions.getByName("android") as BaseExtension
 
         val dexOutputDir = outputFile.get().asFile.parentFile
 
-        Closer.create().use { closer ->
-            val dexBuilder = DexArchiveBuilder.createD8DexBuilder(
-                DexParameters(
-                    minSdkVersion = android.defaultConfig.minSdkVersion?.apiLevel ?: 24,
-                    debuggable = true,
-                    dexPerClass = false,
-                    withDesugaring = true,
-                    desugarBootclasspath = ClassFileProviderFactory(android.bootClasspath.map(File::toPath))
-                        .also { closer.register(it) },
-                    desugarClasspath = ClassFileProviderFactory(listOf<Path>()).also { closer.register(it) },
-                    coreLibDesugarConfig = null,
-                    coreLibDesugarOutputKeepRuleFile = null,
-                    messageReceiver = MessageReceiverImpl(
-                        ErrorFormatMode.HUMAN_READABLE,
-                        LoggerFactory.getLogger(CompileDexTask::class.java)
-                    )
+        val bootClassPath = ClassFileProviderFactory(android.bootClasspath.map(File::toPath))
+        val classPath = ClassFileProviderFactory(listOf<Path>())
+        val dexBuilder = DexArchiveBuilder.createD8DexBuilder(
+            DexParameters(
+                minSdkVersion = android.defaultConfig.minSdkVersion?.apiLevel ?: 24,
+                debuggable = true,
+                dexPerClass = false,
+                withDesugaring = true,
+                desugarBootclasspath = bootClassPath,
+                desugarClasspath = classPath,
+                coreLibDesugarConfig = null,
+                enableApiModeling = true,
+                messageReceiver = MessageReceiverImpl(
+                    ErrorFormatMode.HUMAN_READABLE,
+                    LoggerFactory.getLogger(CompileDexTask::class.java)
                 )
             )
+        )
 
-            val fileStreams =
-                input.map { input -> ClassFileInputs.fromPath(input.toPath()).use { it.entries { _, _ -> true } } }
-                    .toTypedArray()
+        val fileStreams = input.map { input ->
+            ClassFileInputs.fromPath(input.toPath()).use { it.entries { _, _ -> true } }
+        }.toTypedArray()
 
-            Arrays.stream(fileStreams).flatMap { it }
-                .use { classesInput ->
-                    val files = classesInput.collect(Collectors.toList())
+        Arrays.stream(fileStreams).flatMap { it }
+            .use { classesInput ->
+                val files = classesInput.collect(Collectors.toList())
 
-                    dexBuilder.convert(
-                        files.stream(),
-                        dexOutputDir.toPath()
-                    )
+                dexBuilder.convert(
+                    files.stream(),
+                    dexOutputDir.toPath(),
+                    null
+                )
 
-                    for (file in files) {
-                        val reader = ClassReader(file.readAllBytes())
+                for (file in files) {
+                    val reader = ClassReader(file.readAllBytes())
 
-                        val classNode = ClassNode()
-                        reader.accept(classNode, 0)
+                    val classNode = ClassNode()
+                    reader.accept(classNode, 0)
 
-                        for (annotation in classNode.visibleAnnotations.orEmpty() + classNode.invisibleAnnotations.orEmpty()) {
-                            if (annotation.desc == "Lcom/aliucord/annotations/AliucordPlugin;") {
-                                val aliucord = project.extensions.getAliucord()
+                    for (annotation in classNode.visibleAnnotations.orEmpty() + classNode.invisibleAnnotations.orEmpty()) {
+                        if (annotation.desc == "Lcom/aliucord/annotations/AliucordPlugin;") {
+                            val aliucord = project.extensions.getAliucord()
 
-                                require(aliucord.pluginClassName == null) {
-                                    "Only 1 active plugin class per project is supported"
-                                }
+                            require(aliucord.pluginClassName == null) {
+                                "Only 1 active plugin class per project is supported"
+                            }
 
-                                for (method in classNode.methods) {
-                                    if (method.name == "getManifest" && method.desc == "()Lcom/aliucord/entities/Plugin\$Manifest;") {
-                                        throw IllegalArgumentException("Plugin class cannot override getManifest, use manifest.json system!")
-                                    }
+                            for (method in classNode.methods) {
+                                if (method.name == "getManifest" && method.desc == "()Lcom/aliucord/entities/Plugin\$Manifest;") {
+                                    throw IllegalArgumentException("Plugin class cannot override getManifest, use manifest.json system!")
                                 }
-
-                                aliucord.pluginClassName = classNode.name.replace('/', '.')
-                                    .also { pluginClassFile.asFile.orNull?.writeText(it) }
                             }
+
+                            aliucord.pluginClassName = classNode.name.replace('/', '.')
+                                .also { pluginClassFile.asFile.orNull?.writeText(it) }
                         }
                     }
                 }
-        }
+            }
+
+        bootClassPath.close()
+        classPath.close()
 
         logger.lifecycle("Compiled dex to ${outputFile.get()}")
     }

src/main/kotlin/com/aliucord/gradle/task/Tasks.kt

@@ -31,59 +31,59 @@ const val TASK_GROUP = "aliucord"
 
 fun registerTasks(project: Project) {
     val extension = project.extensions.getAliucord()
-    val intermediates = project.buildDir.resolve("intermediates")
+    val intermediates = project.layout.buildDirectory.dir("intermediates").get()
 
     if (project.rootProject.tasks.findByName("generateUpdaterJson") == null) {
         project.rootProject.tasks.register("generateUpdaterJson", GenerateUpdaterJsonTask::class.java) {
-            it.group = TASK_GROUP
+            group = TASK_GROUP
 
-            it.outputs.upToDateWhen { false }
+            outputs.upToDateWhen { false }
 
-            it.outputFile.set(it.project.buildDir.resolve("updater.json"))
+            outputFile.set(project.layout.buildDirectory.file("updater.json"))
         }
     }
 
     project.tasks.register("genSources", GenSourcesTask::class.java) {
-        it.group = TASK_GROUP
+        group = TASK_GROUP
     }
 
-    val pluginClassFile = intermediates.resolve("pluginClass")
+    val pluginClassFile = intermediates.file("pluginClass").asFile
 
     val compileDex = project.tasks.register("compileDex", CompileDexTask::class.java) {
-        it.group = TASK_GROUP
+        group = TASK_GROUP
 
-        it.pluginClassFile.set(pluginClassFile)
+        this.pluginClassFile.set(pluginClassFile)
 
         for (name in arrayOf("compileDebugJavaWithJavac", "compileDebugKotlin")) {
-            val task = project.tasks.findByName(name) as AbstractCompile?
+            val task = project.tasks.findByName(name)
             if (task != null) {
-                it.dependsOn(task)
-                it.input.from(task.destinationDirectory)
+                dependsOn(task)
+                input.from(task.outputs)
             }
         }
 
-        it.outputFile.set(intermediates.resolve("classes.dex"))
+        outputFile.set(intermediates.file("classes.dex"))
     }
 
     val compileResources = project.tasks.register("compileResources", CompileResourcesTask::class.java) {
-        it.group = TASK_GROUP
+        group = TASK_GROUP
 
         val processManifestTask = project.tasks.getByName("processDebugManifest") as ProcessLibraryManifest
-        it.dependsOn(processManifestTask)
+        dependsOn(processManifestTask)
 
         val android = project.extensions.getByName("android") as BaseExtension
-        it.input.set(android.sourceSets.getByName("main").res.srcDirs.single())
-        it.manifestFile.set(processManifestTask.manifestOutputFile)
+        input.set(android.sourceSets.getByName("main").res.srcDirs.single())
+        manifestFile.set(processManifestTask.manifestOutputFile)
 
-        it.outputFile.set(intermediates.resolve("res.apk"))
+        outputFile.set(intermediates.file("res.apk"))
 
-        it.doLast { _ ->
-            val resApkFile = it.outputFile.asFile.get()
+        doLast {
+            val resApkFile = outputFile.asFile.get()
 
             if (resApkFile.exists()) {
                 project.tasks.named("make", AbstractCopyTask::class.java) {
-                    it.from(project.zipTree(resApkFile)) { copySpec ->
-                        copySpec.exclude("AndroidManifest.xml")
+                    from(project.zipTree(resApkFile)) {
+                        exclude("AndroidManifest.xml")
                     }
                 }
             }
@@ -94,17 +94,16 @@ fun registerTasks(project: Project) {
         project.tasks.register(
             "make",
             if (extension.projectType.get() == ProjectType.INJECTOR) Copy::class.java else Zip::class.java
-        )
-        {
-            it.group = TASK_GROUP
+        ) {
+            group = TASK_GROUP
             val compileDexTask = compileDex.get()
-            it.dependsOn(compileDexTask)
+            dependsOn(compileDexTask)
 
             if (extension.projectType.get() == ProjectType.PLUGIN) {
-                val manifestFile = intermediates.resolve("manifest.json")
+                val manifestFile = intermediates.file("manifest.json").asFile
 
-                it.from(manifestFile)
-                it.doFirst {
+                from(manifestFile)
+                doFirst {
                     require(project.version != "unspecified") {
                         "No version is set"
                     }
@@ -137,33 +136,32 @@ fun registerTasks(project: Project) {
                 }
             }
 
-            it.from(compileDexTask.outputFile)
+            from(compileDexTask.outputFile)
 
             if (extension.projectType.get() == ProjectType.INJECTOR) {
-                it.into(project.buildDir)
-                it.rename { return@rename "Injector.dex" }
+                into(project.layout.buildDirectory)
+                rename { return@rename "Injector.dex" }
 
-                it.doLast { task ->
-                    task.logger.lifecycle("Copied Injector.dex to ${project.buildDir}")
+                doLast {
+                    logger.lifecycle("Copied Injector.dex to ${project.layout.buildDirectory}")
                 }
             } else {
-                val zip = it as Zip
-
+                val zip = this as Zip
                 zip.dependsOn(compileResources.get())
                 zip.isPreserveFileTimestamps = false
                 zip.archiveBaseName.set(project.name)
                 zip.archiveVersion.set("")
-                zip.destinationDirectory.set(project.buildDir)
+                zip.destinationDirectory.set(project.layout.buildDirectory)
 
-                it.doLast { task ->
-                    task.logger.lifecycle("Made Aliucord package at ${task.outputs.files.singleFile}")
+                doLast {
+                    logger.lifecycle("Made Aliucord package at ${outputs.files.singleFile}")
                 }
             }
         }
 
         project.tasks.register("deployWithAdb", DeployWithAdbTask::class.java) {
-            it.group = TASK_GROUP
-            it.dependsOn("make")
+            group = TASK_GROUP
+            dependsOn("make")
         }
     }
 }