Migration to Kotlin DSL

app/build.gradle.kts

@@ -0,0 +1,104 @@
+import java.io.FileInputStream
+import java.util.Properties
+
+plugins {
+    alias(libs.plugins.generic.application)
+    alias(libs.plugins.generic.baseline.profm)
+}
+
+android {
+    namespace = "com.shifthackz.aisdv1.app"
+    defaultConfig {
+        applicationId = "com.shifthackz.aisdv1.app"
+        versionName = libs.versions.versionName.get()
+        versionCode = libs.versions.versionCode.get().toInt()
+
+        buildConfigField("String", "IMAGE_CDN_URL", "\"https://random.imagecdn.app/\"")
+        buildConfigField("String", "HUGGING_FACE_URL", "\"https://huggingface.co/\"")
+        buildConfigField("String", "HUGGING_FACE_INFERENCE_URL", "\"https://api-inference.huggingface.co/\"")
+        buildConfigField("String", "HORDE_AI_URL", "\"https://stablehorde.net/\"")
+        buildConfigField("String", "OPEN_AI_URL", "\"https://api.openai.com/\"")
+        buildConfigField("String", "STABILITY_AI_URL", "\"https://api.stability.ai/\"")
+
+        buildConfigField("String", "HORDE_AI_SIGN_UP_URL", "\"https://stablehorde.net/register\"")
+        buildConfigField("String", "HUGGING_FACE_INFO_URL", "\"https://huggingface.co/docs/api-inference/index\"")
+        buildConfigField("String", "OPEN_AI_INFO_URL", "\"https://platform.openai.com/api-keys\"")
+        buildConfigField("String", "STABILITY_AI_INFO_URL", "\"https://platform.stability.ai/\"")
+        buildConfigField("String", "UPDATE_API_URL", "\"https://sdai.moroz.cc\"")
+        buildConfigField("String", "DEMO_MODE_API_URL", "\"https://sdai.moroz.cc\"")
+        buildConfigField("String", "POLICY_URL", "\"https://sdai.moroz.cc/policy.html\"")
+        buildConfigField("String", "DONATE_URL", "\"https://www.buymeacoffee.com/shifthackz\"")
+        buildConfigField("String", "GITHUB_SOURCE_URL", "\"https://github.com/ShiftHackZ/Stable-Diffusion-Android\"")
+        buildConfigField("String", "SETUP_INSTRUCTIONS_URL", "\"https://github.com/AUTOMATIC1111/stable-diffusion-webui/wiki\"")
+        buildConfigField("String", "SWARM_UI_INFO_URL", "\"https://github.com/mcmonkeyprojects/SwarmUI/tree/master/docs\"")
+
+        resourceConfigurations += listOf("en", "ru", "uk", "tr", "zh")
+    }
+
+    val hasPropertiesFile = File("app/keystore/signing.properties").exists()
+    if (hasPropertiesFile) {
+        val props = Properties()
+        props.load(FileInputStream(file("keystore/signing.properties")))
+        val alias = props["keystore.alias"] as String
+        signingConfigs {
+            create("release") {
+                storeFile = file(props["keystore"] as String)
+                storePassword = props["keystore.password"] as String
+                keyAlias = alias
+                keyPassword = props["keystore.password"] as String
+            }
+        }
+        println("[Signature] -> Build will be signed with signature: $alias")
+        buildTypes.getByName("release").signingConfig = signingConfigs.getByName("release")
+    }
+
+    flavorDimensions += "type"
+    productFlavors {
+        create("dev") {
+            dimension = "type"
+            applicationIdSuffix = ".dev"
+            resValue("string", "app_name", "SDAI Dev")
+            buildConfigField("String", "BUILD_FLAVOR_TYPE", "\"FOSS\"")
+        }
+        create("foss") {
+            dimension = "type"
+            applicationIdSuffix = ".foss"
+            resValue("string", "app_name", "SDAI FOSS")
+            buildConfigField("String", "BUILD_FLAVOR_TYPE", "\"FOSS\"")
+        }
+        create("playstore") {
+            dimension = "type"
+            resValue("string", "app_name", "SDAI")
+            buildConfigField("String", "BUILD_FLAVOR_TYPE", "\"GOOGLE_PLAY\"")
+        }
+    }
+}
+
+dependencies {
+    implementation(project(":core:common"))
+    implementation(project(":core:imageprocessing"))
+    implementation(project(":core:notification"))
+    implementation(project(":core:validation"))
+    implementation(project(":presentation"))
+    implementation(project(":network"))
+    implementation(project(":storage"))
+    implementation(project(":domain"))
+    implementation(project(":feature:auth"))
+    implementation(project(":feature:diffusion"))
+    implementation(project(":feature:work"))
+    implementation(project(":data"))
+    implementation(project(":demo"))
+    implementation(libs.koin.core)
+    implementation(libs.koin.android)
+    implementation(libs.koin.compose)
+    implementation(libs.rx.kotlin)
+    implementation(libs.rx.android)
+    implementation(libs.timber)
+    implementation(libs.shifthackz.catppuccin.splash)
+    implementation(libs.shifthackz.catppuccin.legacy)
+    implementation(libs.androidx.work.runtime)
+}
+
+kapt {
+    correctErrorTypes = true
+}

app/proguard-rules.pro

@@ -1,6 +1,6 @@
 # Add project specific ProGuard rules here.
 # You can control the set of applied configuration files using the
-# proguardFiles setting in build.gradle.
+# proguardFiles setting in build.gradle.kts.
 #
 # For more details, see
 #   http://developer.android.com/guide/developing/tools/proguard.html

build-logic/convention/build.gradle.kts

@@ -0,0 +1,44 @@
+plugins {
+    `kotlin-dsl`
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_17
+    targetCompatibility = JavaVersion.VERSION_17
+}
+
+tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile>().configureEach {
+    kotlinOptions {
+        jvmTarget = JavaVersion.VERSION_17.toString()
+    }
+}
+
+dependencies {
+    compileOnly(libs.android.tools.build.gradle)
+    compileOnly(libs.kotlin.gradle.plugin)
+}
+
+gradlePlugin {
+    plugins {
+        register("Library") {
+            id = "generic.library"
+            implementationClass = "LibraryConventionPlugin"
+        }
+        register("Jacoco") {
+            id = "generic.jacoco"
+            implementationClass = "JacocoConventionPlugin"
+        }
+        register("Compose") {
+            id = "generic.compose"
+            implementationClass = "ComposeConventionPlugin"
+        }
+        register("Application") {
+            id = "generic.application"
+            implementationClass = "ApplicationConventionPlugin"
+        }
+        register("BaselineProFm") {
+            id = "generic.baseline.profm"
+            implementationClass = "BaselineProFmConventionPlugin"
+        }
+    }
+}

build-logic/convention/src/main/kotlin/ApplicationConventionPlugin.kt

@@ -0,0 +1,27 @@
+import com.android.build.api.dsl.ApplicationExtension
+import com.shifthackz.aisdv1.buildlogic.configureApplication
+import com.shifthackz.aisdv1.buildlogic.configureCompose
+import com.shifthackz.aisdv1.buildlogic.libs
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.configure
+
+class ApplicationConventionPlugin : Plugin<Project> {
+
+    override fun apply(target: Project) {
+        with(target) {
+            with(pluginManager) {
+                apply("com.android.application")
+                apply("org.jetbrains.kotlin.android")
+                apply("org.jetbrains.kotlin.kapt")
+                apply("generic.jacoco")
+            }
+
+            extensions.configure<ApplicationExtension> {
+                configureApplication(this)
+                configureCompose(this)
+                defaultConfig.targetSdk = libs.findVersion("targetSdk").get().toString().toInt()
+            }
+        }
+    }
+}

build-logic/convention/src/main/kotlin/BaselineProFmConventionPlugin.kt

@@ -0,0 +1,60 @@
+@file:Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import com.android.tools.profgen.ArtProfile
+import com.android.tools.profgen.ArtProfileSerializer
+import com.android.tools.profgen.DexFile
+import com.android.tools.profgen.DexFileData
+import java.io.FileOutputStream
+import java.util.Collections
+
+/**
+ * Workaround for "Bug: baseline.profm not deterministic"
+ *
+ * Reference     : https://f-droid.org/docs/Reproducible_Builds/#bug-baselineprofm-not-deterministic
+ * Fix snippet   : https://gist.github.com/obfusk/61046e09cee352ae6dd109911534b12e
+ * Issue tracker : https://issuetracker.google.com/issues/231837768
+ */
+class BaselineProFmConventionPlugin : Plugin<Project> {
+
+    override fun apply(target: Project) {
+        target.afterEvaluate {
+            tasks.forEach { task ->
+                if (task.name.startsWith("compile") && task.name.endsWith("ReleaseArtProfile")) {
+                    task.doLast {
+                        outputs.files.forEach { file ->
+                            if (file.name.endsWith(".profm")) {
+                                println("[Baseline ProFm] -> Trying to sort: $file")
+                                val version = ArtProfileSerializer.valueOf("METADATA_0_0_2")
+                                val profile = ArtProfile(file)
+                                val keys = ArrayList(profile?.profileData?.keys ?: setOf())
+                                val sortedData = LinkedHashMap<DexFile, DexFileData>()
+                                println("[Baseline ProFm] -> Keys: $keys")
+                                Collections.sort(keys, DexFile.Companion)
+                                println("[Baseline ProFm] -> Keys (sorted): $keys")
+
+                                keys.forEach { key ->
+                                    profile?.profileData?.get(key)?.let { value ->
+                                        sortedData[key] = value
+                                    }
+                                }
+                                println("[Baseline ProFm] -> Sorted data: $sortedData")
+
+                                FileOutputStream(file).use { stream ->
+                                    println("[Baseline ProFm] -> Writing magic bytes...")
+                                    stream.write(version.magicBytes)
+                                    println("[Baseline ProFm] -> Writing version bytes...")
+                                    stream.write(version.versionBytes)
+                                    println("[Baseline ProFm] -> Writing sorted data...")
+                                    version.write(stream, sortedData, "")
+                                }
+                                println("[Baseline ProFm] -> Done!")
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}