refactor: 프로젝트 버전 관리

build-logic/convention/build.gradle.kts

@@ -11,10 +11,37 @@ java {
 
 dependencies {
     compileOnly(libs.kotlin.gradleplugin)
+    compileOnly(libs.agp)
+    compileOnly(libs.ksp.gradlePlugin)
 }
 
 gradlePlugin {
     plugins {
+        create("android-application") {
+            id = "com.murjune.practice.application"
+            implementationClass =
+                "com.murjune.practice.plugins.AndroidApplicationPlugin"
+        }
+        create("android-library") {
+            id = "com.murjune.practice.library"
+            implementationClass = "com.murjune.practice.plugins.AndroidLibraryPlugin"
+        }
+        create("android-feature") {
+            id = "com.murjune.practice.feature"
+            implementationClass = "com.murjune.practice.plugins.AndroidFeaturePlugin"
+        }
+        create("android-hilt") {
+            id = "com.murjune.practice.hilt"
+            implementationClass = "com.murjune.practice.plugins.AndroidHiltPlugin"
+        }
+        create("android-test") {
+            id = "com.murjune.practice.android.test"
+            implementationClass = "com.murjune.practice.plugins.AndroidTestPlugin"
+        }
+        create("compose") {
+            id = "com.murjune.practice.compose"
+            implementationClass = "com.murjune.practice.plugins.ComposePlugin"
+        }
         create("kotlin-serialization") {
             id = "com.murjune.practice.kotlinx_serialization"
             implementationClass =
@@ -26,8 +53,8 @@ gradlePlugin {
             implementationClass = "com.murjune.practice.plugins.KotlinModulePlugin"
         }
 
-        create("junit5") {
-            id = "com.murjune.practice.junit5"
+        create("unit-test") {
+            id = "com.murjune.practice.unit.test"
             implementationClass = "com.murjune.practice.plugins.JUnit5Plugin"
         }
 

build-logic/convention/src/main/kotlin/com/murjune/practice/plugins/AndroidApplicationPlugin.kt

@@ -0,0 +1,36 @@
+package com.murjune.practice.plugins
+
+import com.android.build.api.dsl.ApplicationExtension
+import com.murjune.practice.plugins.utils.configureAndroidCommonPlugin
+import com.murjune.practice.plugins.utils.configureKotlinAndroid
+import com.murjune.practice.plugins.utils.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 AndroidApplicationPlugin : Plugin<Project> {
+    override fun apply(target: Project) {
+        with(target) {
+            with(pluginManager) {
+                apply("com.android.application")
+                apply("kotlin-android")
+            }
+            configureAndroidCommonPlugin()
+
+            extensions.configure<ApplicationExtension> {
+                configureKotlinAndroid(this)
+                defaultConfig.targetSdk =
+                    libs.findVersion("targetSdk").get().requiredVersion.toInt()
+            }
+            dependencies {
+                add("implementation", libs.findLibrary("core.ktx").get())
+                add("implementation", libs.findLibrary("appcompat").get())
+                add("implementation", libs.findBundle("lifecycle").get())
+                add("implementation", libs.findLibrary("material").get())
+                add("testImplementation", kotlin("test"))
+            }
+        }
+    }
+}

build-logic/convention/src/main/kotlin/com/murjune/practice/plugins/AndroidFeaturePlugin.kt

@@ -0,0 +1,24 @@
+package com.murjune.practice.plugins
+
+import com.murjune.practice.plugins.utils.libs
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.apply
+import org.gradle.kotlin.dsl.dependencies
+import org.gradle.kotlin.dsl.kotlin
+
+class AndroidFeaturePlugin : Plugin<Project> {
+    override fun apply(target: Project) {
+        with(target) {
+            apply<AndroidLibraryPlugin>()
+
+            dependencies {
+                add("implementation", libs.findLibrary("core.ktx").get())
+                add("implementation", libs.findLibrary("appcompat").get())
+                add("implementation", libs.findBundle("lifecycle").get())
+                add("implementation", libs.findLibrary("material").get())
+                add("testImplementation", kotlin("test"))
+            }
+        }
+    }
+}

build-logic/convention/src/main/kotlin/com/murjune/practice/plugins/AndroidHiltPlugin.kt

@@ -0,0 +1,22 @@
+package com.murjune.practice.plugins
+
+import com.murjune.practice.plugins.utils.libs
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.dependencies
+
+class AndroidHiltPlugin : Plugin<Project> {
+    override fun apply(target: Project) =
+        with(target) {
+            with(plugins) {
+                apply("com.google.devtools.ksp")
+                apply("dagger.hilt.android.plugin")
+            }
+
+            dependencies {
+                add("implementation", libs.findLibrary("hilt.navigation.compose").get())
+                add("implementation", libs.findLibrary("hilt.android").get())
+                add("ksp", libs.findLibrary("hilt.compiler").get())
+            }
+        }
+}

build-logic/convention/src/main/kotlin/com/murjune/practice/plugins/AndroidLibraryPlugin.kt

@@ -0,0 +1,26 @@
+package com.murjune.practice.plugins
+
+import com.android.build.gradle.LibraryExtension
+import com.murjune.practice.plugins.utils.configureAndroidCommonPlugin
+import com.murjune.practice.plugins.utils.configureKotlinAndroid
+import com.murjune.practice.plugins.utils.libs
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.configure
+
+class AndroidLibraryPlugin : Plugin<Project> {
+    override fun apply(target: Project) =
+        with(target) {
+            with(pluginManager) {
+                apply("com.android.library")
+                apply("kotlin-android")
+            }
+            configureAndroidCommonPlugin()
+
+            extensions.configure<LibraryExtension> {
+                configureKotlinAndroid(this)
+                defaultConfig.targetSdk =
+                    libs.findVersion("targetSdk").get().requiredVersion.toInt()
+            }
+        }
+}

build-logic/convention/src/main/kotlin/com/murjune/practice/plugins/AndroidTestPlugin.kt

@@ -0,0 +1,44 @@
+package com.murjune.practice.plugins
+
+import com.android.build.gradle.BaseExtension
+import com.murjune.practice.plugins.utils.libs
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.apply
+import org.gradle.kotlin.dsl.dependencies
+import org.gradle.kotlin.dsl.getByType
+
+class AndroidTestPlugin : Plugin<Project> {
+    override fun apply(target: Project): Unit = with(target) {
+        with(pluginManager) {
+            apply<UnitTestPlugin>()
+            apply("de.mannodermaus.android-junit5")
+        }
+
+        extensions.getByType<BaseExtension>().apply {
+            defaultConfig {
+                testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+                testInstrumentationRunnerArguments["runnerBuilder"] =
+                    "de.mannodermaus.junit5.AndroidJUnit5Builder"
+            }
+
+            testOptions {
+                unitTests {
+                    isIncludeAndroidResources = true
+                }
+            }
+
+            packagingOptions {
+                resources.excludes.add("META-INF/LICENSE*")
+            }
+        }
+
+        dependencies {
+            add("androidTestImplementation", libs.findBundle("unit-test").get())
+            add("testImplementation", libs.findLibrary("robolectric").get())
+            add("androidTestImplementation", libs.findLibrary("junit5-android-test-core").get())
+            add("androidTestRuntimeOnly", libs.findLibrary("junit5-android-test-runner").get())
+            add("androidTestImplementation", libs.findBundle("androidx-android-test").get())
+        }
+    }
+}

build-logic/convention/src/main/kotlin/com/murjune/practice/plugins/ComposePlugin.kt

@@ -0,0 +1,28 @@
+package com.murjune.practice.plugins
+
+import com.android.build.gradle.BaseExtension
+import com.murjune.practice.plugins.utils.libs
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.dependencies
+import org.gradle.kotlin.dsl.getByType
+
+class ComposePlugin : Plugin<Project> {
+    override fun apply(target: Project) =
+        with(target) {
+            extensions.getByType<BaseExtension>().apply {
+                buildFeatures.apply {
+                    compose = true
+                }
+                composeOptions {
+                    kotlinCompilerExtensionVersion =
+                        libs.findVersion("composeCompiler").get().toString()
+                }
+            }
+
+            dependencies {
+                add("implementation", platform(libs.findLibrary("compose.bom").get()))
+                add("implementation", libs.findBundle("compose").get())
+            }
+        }
+}

build-logic/convention/src/main/kotlin/com/murjune/practice/plugins/KotlinModulePlugin.kt

@@ -11,7 +11,7 @@ class KotlinModulePlugin : Plugin<Project> {
     override fun apply(target: Project) {
         with(target) {
             apply<JvmLibraryPlugin>()
-            apply<JUnit5Plugin>()
+            apply<UnitTestPlugin>()
         }
 
     }

build-logic/convention/src/main/kotlin/com/murjune/practice/plugins/JUnit5Plugin.kt → build-logic/convention/src/main/kotlin/com/murjune/practice/plugins/UnitTestPlugin.kt

@@ -8,7 +8,7 @@ import org.gradle.kotlin.dsl.dependencies
 import org.gradle.kotlin.dsl.kotlin
 import org.gradle.kotlin.dsl.withType
 
-class JUnit5Plugin : Plugin<Project> {
+class UnitTestPlugin : Plugin<Project> {
     override fun apply(target: Project): Unit =
         with(target) {
 
@@ -18,10 +18,7 @@ class JUnit5Plugin : Plugin<Project> {
 
             dependencies {
                 add("testImplementation", kotlin("test"))
-                add("testImplementation", libs.findBundle("junit5").get())
-                add("testImplementation", libs.findLibrary("assertj").get())
-                add("testImplementation", libs.findLibrary("kotlin-coroutines-test").get())
-                add("testImplementation", libs.findLibrary("kotest").get())
+                add("testImplementation", libs.findBundle("unit-test").get())
             }
         }
 }

build-logic/convention/src/main/kotlin/com/murjune/practice/plugins/utils/AndroidCommonConfigs.kt

@@ -0,0 +1,22 @@
+package com.murjune.practice.plugins.utils
+
+import com.android.build.gradle.BaseExtension
+import com.murjune.practice.plugins.AndroidHiltPlugin
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.apply
+import org.gradle.kotlin.dsl.dependencies
+import org.gradle.kotlin.dsl.getByType
+
+internal fun Project.configureAndroidCommonPlugin() {
+    apply<AndroidHiltPlugin>()
+
+    extensions.getByType<BaseExtension>().apply {
+        buildFeatures.apply {
+            buildConfig = true
+        }
+    }
+
+    dependencies {
+        add("implementation", libs.findLibrary("timber").get())
+    }
+}

build-logic/convention/src/main/kotlin/com/murjune/practice/plugins/utils/KotlinConfigs.kt

@@ -1,5 +1,6 @@
 package com.murjune.practice.plugins.utils
 
+import com.android.build.api.dsl.CommonExtension
 import org.gradle.api.JavaVersion
 import org.gradle.api.Project
 import org.gradle.api.plugins.JavaPluginExtension
@@ -8,6 +9,34 @@ import org.gradle.kotlin.dsl.dependencies
 import org.gradle.kotlin.dsl.withType
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
+/**
+ * Configure base Kotlin with Android options
+ */
+internal fun Project.configureKotlinAndroid(
+    commonExtension: CommonExtension<*, *, *, *, *>,
+) {
+    commonExtension.apply {
+        compileSdk = libs.findVersion("compileSdk").get().requiredVersion.toInt()
+
+        defaultConfig {
+            minSdk = libs.findVersion("minSdk").get().requiredVersion.toInt()
+        }
+
+        compileOptions {
+//            isCoreLibraryDesugaringEnabled = true
+            sourceCompatibility = JavaVersion.VERSION_17
+            targetCompatibility = JavaVersion.VERSION_17
+        }
+    }
+
+    configureKotlin()
+
+    dependencies {
+        add("implementation", libs.findLibrary("kotlin").get())
+        add("implementation", libs.findLibrary("kotlin.coroutines.android").get())
+    }
+}
+
 /**
  * Configure base Kotlin options for JVM (non-Android)
  */

build.gradle.kts

@@ -7,11 +7,19 @@ buildscript {
 
     dependencies {
         classpath(libs.kotlin.gradleplugin)
+        classpath(libs.hilt.plugin)
+        classpath(libs.agp)
         classpath(libs.ktlint)
     }
 }
 
 plugins {
+    alias(libs.plugins.android.application) apply false
+    alias(libs.plugins.android.library) apply false
+    alias(libs.plugins.kotlin.android) apply false
+    alias(libs.plugins.kotlin.kapt) apply false
+    alias(libs.plugins.dagger.hilt) apply false
+    alias(libs.plugins.ksp) apply false
     alias(libs.plugins.kotlinx.serialization) apply false
     alias(libs.plugins.junit5) apply false
     alias(libs.plugins.ktlint) apply false

gradle.properties

@@ -1 +1,28 @@
+# Project-wide Gradle settings.
+# IDE (e.g. Android Studio) users:
+# Gradle settings configured through the IDE *will override*
+# any settings specified in this file.
+# For more details on how to configure your build environment visit
+# http://www.gradle.org/docs/current/userguide/build_environment.html
+# Specifies the JVM arguments used for the daemon process.
+# The setting is particularly useful for tweaking memory settings.
+org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8
+org.gradle.parallel=true
+# Enable caching between builds.
+org.gradle.caching=true
+
+# When configured, Gradle will run in incubating parallel mode.
+# This option should only be used with decoupled projects. More details, visit
+# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
+# org.gradle.parallel=true
+# AndroidX package structure to make it clearer which packages are bundled with the
+# Android operating system, and which are packaged with your app's APK
+# https://developer.android.com/topic/libraries/support-library/androidx-rn
+android.useAndroidX=true
+# Kotlin code style for this project: "official" or "obsolete":
 kotlin.code.style=official
+# Enables namespacing of each library's R class so that its R class includes only the
+# resources declared in the library itself and none from the library's dependencies,
+# thereby reducing the size of the R class for that library
+android.nonTransitiveRClass=true
+android.enableJetifier=true