Convention plugins

README.md

@@ -17,10 +17,18 @@ The project is designed as:
     - [ ] A Merchant App to sell items
     - [ ] Admin App to check on status of everything
 
--
+
+### [Tech Stack 🛠]
+- [ ] Kotlin
+- [ ] Jetpack Compose
+
+*use JVM 21*
+
+### [Features 🚀]
+
 
 
 ## Contributing
- Hop on here for a chat and ask questions. NO DMs please :)
+ Create an [issue here](https://github.com/droidconKE/doko/issues) and ask questions. NO DMs please :)
 
 

buildLogic/convention/build.gradle.kts

@@ -0,0 +1,86 @@
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+
+plugins {
+    `kotlin-dsl`
+}
+
+group = "com.droidconke.doko.buildlogic"
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_21
+    targetCompatibility = JavaVersion.VERSION_21
+}
+
+kotlin {
+    compilerOptions {
+        jvmTarget = JvmTarget.JVM_21
+    }
+}
+
+dependencies {
+    compileOnly(libs.android.gradlePlugin)
+    compileOnly(libs.android.tools.common)
+    compileOnly(libs.compose.gradlePlugin)
+    compileOnly(libs.firebase.crashlytics.gradlePlugin)
+    compileOnly(libs.firebase.performance.gradlePlugin)
+    compileOnly(libs.kotlin.gradlePlugin)
+    compileOnly(libs.ksp.gradlePlugin)
+    compileOnly(libs.room.gradlePlugin)
+    implementation(libs.truth)
+}
+
+tasks {
+    validatePlugins {
+        enableStricterValidation = true
+        failOnWarning = true
+    }
+}
+
+gradlePlugin {
+    plugins {
+        register("androidApplicationCompose") {
+            id = "doko.android.application.compose"
+            implementationClass = "AndroidApplicationComposeConventionPlugin"
+        }
+        register("androidApplication") {
+            id = "doko.android.application"
+            implementationClass = "AndroidApplicationConventionPlugin"
+        }
+        register("androidLibraryCompose") {
+            id = "doko.android.library.compose"
+            implementationClass = "AndroidLibraryComposeConventionPlugin"
+        }
+        register("androidLibrary") {
+            id = "doko.android.library"
+            implementationClass = "AndroidLibraryConventionPlugin"
+        }
+        register("androidFeature") {
+            id = "doko.android.feature"
+            implementationClass = "AndroidFeatureConventionPlugin"
+        }
+        register("androidTest") {
+            id = "doko.android.test"
+            implementationClass = "AndroidTestConventionPlugin"
+        }
+        register("hilt") {
+            id = "doko.hilt"
+            implementationClass = "HiltConventionPlugin"
+        }
+        register("androidRoom") {
+            id = "doko.android.room"
+            implementationClass = "AndroidRoomConventionPlugin"
+        }
+        register("androidFirebase") {
+            id = "doko.android.application.firebase"
+            implementationClass = "AndroidApplicationFirebaseConventionPlugin"
+        }
+        register("androidLint") {
+            id = "doko.android.lint"
+            implementationClass = "AndroidLintConventionPlugin"
+        }
+        register("jvmLibrary") {
+            id = "doko.jvm.library"
+            implementationClass = "JvmLibraryConventionPlugin"
+        }
+    }
+}

buildLogic/convention/src/main/kotlin/AndroidApplicationComposeConventionPlugin.kt

@@ -0,0 +1,19 @@
+import com.android.build.api.dsl.ApplicationExtension
+import com.droidconke.doko.configureAndroidCompose
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.apply
+import org.gradle.kotlin.dsl.getByType
+
+class AndroidApplicationComposeConventionPlugin : Plugin<Project> {
+    override fun apply(target: Project) {
+        with(target) {
+            apply(plugin = "com.android.application")
+            apply(plugin = "org.jetbrains.kotlin.plugin.compose")
+            apply(plugin = "org.jetbrains.kotlin.android")
+
+            val extension = extensions.getByType<ApplicationExtension>()
+            configureAndroidCompose(extension)
+        }
+    }
+}

buildLogic/convention/src/main/kotlin/AndroidApplicationConventionPlugin.kt

@@ -0,0 +1,27 @@
+import com.android.build.api.dsl.ApplicationExtension
+import com.droidconke.doko.configureKotlinAndroid
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.configure
+
+
+class AndroidApplicationConventionPlugin : Plugin<Project> {
+    override fun apply(target: Project) {
+        with(target) {
+            with(pluginManager) {
+                apply("com.android.application")
+                apply("org.jetbrains.kotlin.android")
+                apply("com.dropbox.dependency-guard")
+                apply("doko.android.lint")
+            }
+
+            extensions.configure<ApplicationExtension> {
+                configureKotlinAndroid(this)
+                defaultConfig.targetSdk = 34
+                defaultConfig.minSdk = 28
+                @Suppress("UnstableApiUsage")
+                testOptions.animationsDisabled = true
+            }
+        }
+    }
+}

buildLogic/convention/src/main/kotlin/AndroidApplicationFirebaseConventionPlugin.kt

@@ -0,0 +1,38 @@
+import com.android.build.api.dsl.ApplicationExtension
+import com.google.firebase.crashlytics.buildtools.gradle.CrashlyticsExtension
+import com.droidconke.doko.libs
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.configure
+import org.gradle.kotlin.dsl.dependencies
+
+class AndroidApplicationFirebaseConventionPlugin : Plugin<Project> {
+    override fun apply(target: Project) {
+        with(target) {
+            with(pluginManager) {
+                apply("com.google.gms.google-services")
+                apply("com.google.firebase.firebase-perf")
+                apply("com.google.firebase.crashlytics")
+            }
+
+            dependencies {
+                val bom = libs.findLibrary("firebase-bom").get()
+                add("implementation", platform(bom))
+                "implementation"(libs.findLibrary("firebase.analytics").get())
+                "implementation"(libs.findLibrary("firebase.performance").get())
+                "implementation"(libs.findLibrary("firebase.crashlytics").get())
+            }
+
+            extensions.configure<ApplicationExtension> {
+                buildTypes.configureEach {
+                    // Disable the Crashlytics mapping file upload. This feature should only be
+                    // enabled if a Firebase backend is available and configured in
+                    // google-services.json.
+                    configure<CrashlyticsExtension> {
+                        mappingFileUploadEnabled = false
+                    }
+                }
+            }
+        }
+    }
+}

buildLogic/convention/src/main/kotlin/AndroidFeatureConventionPlugin.kt

@@ -0,0 +1,31 @@
+import com.android.build.gradle.LibraryExtension
+import com.droidconke.doko.libs
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.configure
+import org.gradle.kotlin.dsl.dependencies
+
+
+class AndroidFeatureConventionPlugin : Plugin<Project> {
+    override fun apply(target: Project) {
+        with(target) {
+            pluginManager.apply {
+                apply("doko.android.library")
+                apply("doko.hilt")
+            }
+            extensions.configure<LibraryExtension> {
+                testOptions.animationsDisabled = true
+            }
+
+            dependencies {
+
+                add("implementation", libs.findLibrary("androidx.hilt.navigation.compose").get())
+                add("implementation", libs.findLibrary("androidx.lifecycle.runtimeCompose").get())
+                add("implementation", libs.findLibrary("androidx.lifecycle.viewModelCompose").get())
+                add("implementation", libs.findLibrary("androidx.tracing.ktx").get())
+
+                add("androidTestImplementation", libs.findLibrary("androidx.lifecycle.runtimeTesting").get())
+            }
+        }
+    }
+}

buildLogic/convention/src/main/kotlin/AndroidLibraryComposeConventionPlugin.kt

@@ -0,0 +1,19 @@
+import com.android.build.gradle.LibraryExtension
+import com.droidconke.doko.configureAndroidCompose
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.apply
+import org.gradle.kotlin.dsl.getByType
+
+
+class AndroidLibraryComposeConventionPlugin : Plugin<Project> {
+    override fun apply(target: Project) {
+        with(target) {
+            apply(plugin = "com.android.library")
+            apply(plugin = "org.jetbrains.kotlin.plugin.compose")
+
+            val extension = extensions.getByType<LibraryExtension>()
+            configureAndroidCompose(extension)
+        }
+    }
+}

buildLogic/convention/src/main/kotlin/AndroidLibraryConventionPlugin.kt

@@ -0,0 +1,44 @@
+import com.android.build.api.variant.LibraryAndroidComponentsExtension
+import com.android.build.gradle.LibraryExtension
+import com.droidconke.doko.configureKotlinAndroid
+import com.droidconke.doko.disableUnnecessaryAndroidTests
+import com.droidconke.doko.libs
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.configure
+import org.gradle.kotlin.dsl.dependencies
+import org.gradle.kotlin.dsl.kotlin
+
+
+
+class AndroidLibraryConventionPlugin : Plugin<Project> {
+    override fun apply(target: Project) {
+        with(target) {
+            with(pluginManager) {
+                apply("com.android.library")
+                apply("org.jetbrains.kotlin.android")
+                apply("doko.android.lint")
+            }
+
+            extensions.configure<LibraryExtension> {
+                configureKotlinAndroid(this)
+                defaultConfig.targetSdk = 34
+                defaultConfig.testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+                testOptions.animationsDisabled = true
+                // The resource prefix is derived from the module name,
+                // so resources inside ":core:module1" must be prefixed with "core_module1_"
+                resourcePrefix = path
+                    .split("""\W""".toRegex()).drop(1).distinct().joinToString(separator = "_").lowercase() + "_"
+            }
+            extensions.configure<LibraryAndroidComponentsExtension> {
+                disableUnnecessaryAndroidTests(target)
+            }
+            dependencies {
+                add("androidTestImplementation", kotlin("test"))
+                add("testImplementation", kotlin("test"))
+
+                add("implementation", libs.findLibrary("androidx.tracing.ktx").get())
+            }
+        }
+    }
+}

buildLogic/convention/src/main/kotlin/AndroidLintConventionPlugin.kt

@@ -0,0 +1,32 @@
+import com.android.build.api.dsl.ApplicationExtension
+import com.android.build.api.dsl.LibraryExtension
+import com.android.build.api.dsl.Lint
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.configure
+
+
+class AndroidLintConventionPlugin : Plugin<Project> {
+    override fun apply(target: Project) {
+        with(target) {
+            when {
+                pluginManager.hasPlugin("com.android.application") ->
+                    configure<ApplicationExtension> { lint(Lint::configure) }
+
+                pluginManager.hasPlugin("com.android.library") ->
+                    configure<LibraryExtension> { lint(Lint::configure) }
+
+                else -> {
+                    pluginManager.apply("com.android.lint")
+                    configure<Lint>(Lint::configure)
+                }
+            }
+        }
+    }
+}
+
+private fun Lint.configure() {
+    xmlReport = true
+    checkDependencies = true
+}
+