[Refactor/#200] Gradle 설정 최신화 및 앱 버전 관리 아키텍처 개선

app/src/main/AndroidManifest.xml

@@ -1,6 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:tools="http://schemas.android.com/tools">
+    xmlns:tools="http://schemas.android.com/tools"
+    android:installLocation="auto">
 
     <uses-permission android:name="android.permission.INTERNET" />
     <uses-permission android:name="android.permission.CAMERA" />

app/src/main/java/com/threegap/bitnagil/MainNavHost.kt

@@ -2,7 +2,7 @@ package com.threegap.bitnagil
 
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
-import androidx.hilt.navigation.compose.hiltViewModel
+import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
 import androidx.navigation.compose.NavHost
 import androidx.navigation.compose.composable
 import androidx.navigation.toRoute

app/src/main/java/com/threegap/bitnagil/di/data/AppVersionModule.kt

@@ -0,0 +1,25 @@
+package com.threegap.bitnagil.di.data
+
+import com.threegap.bitnagil.BuildConfig
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import javax.inject.Named
+
+@Module
+@InstallIn(SingletonComponent::class)
+object AppVersionModule {
+
+    @Provides
+    @Named("versionMajor")
+    fun provideVersionMajor(): Int = BuildConfig.VERSION_MAJOR
+
+    @Provides
+    @Named("versionMinor")
+    fun provideVersionMinor(): Int = BuildConfig.VERSION_MINOR
+
+    @Provides
+    @Named("versionPatch")
+    fun provideVersionPatch(): Int = BuildConfig.VERSION_PATCH
+}

app/src/main/java/com/threegap/bitnagil/di/presentation/VersionNameProviderModule.kt

@@ -1,7 +1,7 @@
 package com.threegap.bitnagil.di.presentation
 
-import com.threegap.bitnagil.presentation.util.version.AndroidApplicationVersionNameProvider
 import com.threegap.bitnagil.presentation.util.version.VersionNameProvider
+import com.threegap.bitnagil.util.version.PackageManagerVersionNameProvider
 import dagger.Binds
 import dagger.Module
 import dagger.hilt.InstallIn
@@ -13,5 +13,5 @@ import javax.inject.Singleton
 abstract class VersionNameProviderModule {
     @Binds
     @Singleton
-    abstract fun bindVersionNameProvider(androidApplicationVersionNameProvider: AndroidApplicationVersionNameProvider): VersionNameProvider
+    abstract fun bindVersionNameProvider(impl: PackageManagerVersionNameProvider): VersionNameProvider
 }

app/src/main/java/com/threegap/bitnagil/util/version/PackageManagerVersionNameProvider.kt

@@ -0,0 +1,13 @@
+package com.threegap.bitnagil.util.version
+
+import android.content.Context
+import com.threegap.bitnagil.presentation.util.version.VersionNameProvider
+import dagger.hilt.android.qualifiers.ApplicationContext
+import javax.inject.Inject
+
+class PackageManagerVersionNameProvider @Inject constructor(
+    @param:ApplicationContext private val context: Context,
+) : VersionNameProvider {
+    override fun getVersionName(): String =
+        context.packageManager.getPackageInfo(context.packageName, 0).versionName.orEmpty()
+}

build-logic/convention/build.gradle.kts

@@ -46,5 +46,15 @@ gradlePlugin {
             id = "bitnagil.kotlin"
             implementationClass = "com.threegap.bitnagil.convention.KotlinJvmPlugin"
         }
+
+        register("kotlinSerialization") {
+            id = "bitnagil.kotlin.serialization"
+            implementationClass = "com.threegap.bitnagil.convention.KotlinSerializationPlugin"
+        }
+
+        register("kotlinParcelize") {
+            id = "bitnagil.kotlin.parcelize"
+            implementationClass = "com.threegap.bitnagil.convention.KotlinParcelizePlugin"
+        }
     }
 }

build-logic/convention/src/main/java/com/threegap/bitnagil/convention/AndroidApplicationPlugin.kt

@@ -1,33 +1,30 @@
 package com.threegap.bitnagil.convention
 
 import com.android.build.api.dsl.ApplicationExtension
+import com.threegap.bitnagil.convention.extension.basePackage
 import com.threegap.bitnagil.convention.extension.configureAppVersion
-import com.threegap.bitnagil.convention.extension.configureApplicationId
 import com.threegap.bitnagil.convention.extension.configureComposeAndroid
 import com.threegap.bitnagil.convention.extension.configureKotlinAndroid
+import com.threegap.bitnagil.convention.extension.libs
 import org.gradle.api.Plugin
 import org.gradle.api.Project
-import org.gradle.api.artifacts.VersionCatalogsExtension
-import org.gradle.kotlin.dsl.getByType
 import org.gradle.kotlin.dsl.configure
 
 class AndroidApplicationPlugin : Plugin<Project> {
     override fun apply(target: Project): Unit = with(target) {
         pluginManager.apply {
             apply("com.android.application")
-            apply("org.jetbrains.kotlin.android")
             apply("org.jetbrains.kotlin.plugin.compose")
+            apply("org.jlleitschuh.gradle.ktlint")
         }
 
-        val libs = extensions.getByType<VersionCatalogsExtension>().named("libs")
         extensions.configure<ApplicationExtension> {
             configureKotlinAndroid(this)
             configureComposeAndroid(this)
-            configureAppVersion()
-            configureApplicationId()
+            configureAppVersion(this)
             with(defaultConfig) {
+                applicationId = basePackage
                 targetSdk = libs.findVersion("targetSdk").get().requiredVersion.toInt()
-                versionCode = libs.findVersion("versionCode").get().requiredVersion.toInt()
             }
         }
     }

build-logic/convention/src/main/java/com/threegap/bitnagil/convention/AndroidComposePlugin.kt

@@ -1,6 +1,6 @@
 package com.threegap.bitnagil.convention
 
-import com.android.build.gradle.LibraryExtension
+import com.android.build.api.dsl.LibraryExtension
 import com.threegap.bitnagil.convention.extension.configureComposeAndroid
 import org.gradle.api.Plugin
 import org.gradle.api.Project

build-logic/convention/src/main/java/com/threegap/bitnagil/convention/AndroidLibraryPlugin.kt

@@ -1,8 +1,6 @@
 package com.threegap.bitnagil.convention
 
-import com.android.build.gradle.LibraryExtension
-import com.threegap.bitnagil.convention.extension.configureAppVersion
-import com.threegap.bitnagil.convention.extension.configureApplicationId
+import com.android.build.api.dsl.LibraryExtension
 import com.threegap.bitnagil.convention.extension.configureKotlinAndroid
 import com.threegap.bitnagil.convention.extension.configureKotlinCoroutine
 import org.gradle.api.Plugin
@@ -13,14 +11,12 @@ class AndroidLibraryPlugin : Plugin<Project> {
     override fun apply(target: Project): Unit = with(target) {
         pluginManager.apply {
             apply("com.android.library")
-            apply("org.jetbrains.kotlin.android")
+            apply("org.jlleitschuh.gradle.ktlint")
         }
 
         extensions.configure<LibraryExtension> {
             configureKotlinAndroid(this)
-            configureKotlinCoroutine(this)
-            configureAppVersion()
-            configureApplicationId()
+            configureKotlinCoroutine()
         }
     }
 }

build-logic/convention/src/main/java/com/threegap/bitnagil/convention/HiltPlugin.kt

@@ -1,10 +1,9 @@
 package com.threegap.bitnagil.convention
 
+import com.threegap.bitnagil.convention.extension.libs
 import org.gradle.api.Plugin
 import org.gradle.api.Project
-import org.gradle.api.artifacts.VersionCatalogsExtension
 import org.gradle.kotlin.dsl.dependencies
-import org.gradle.kotlin.dsl.getByType
 
 class HiltPlugin : Plugin<Project> {
     override fun apply(target: Project): Unit = with(target) {
@@ -13,7 +12,6 @@ class HiltPlugin : Plugin<Project> {
             apply("com.google.devtools.ksp")
         }
 
-        val libs = extensions.getByType<VersionCatalogsExtension>().named("libs")
         dependencies {
             "implementation"(libs.findLibrary("hilt.android").get())
             "ksp"(libs.findLibrary("hilt.compiler").get())

build-logic/convention/src/main/java/com/threegap/bitnagil/convention/KotlinJvmPlugin.kt

@@ -13,6 +13,7 @@ class KotlinJvmPlugin : Plugin<Project> {
             pluginManager.apply {
                 apply("java-library")
                 apply("org.jetbrains.kotlin.jvm")
+                apply("org.jlleitschuh.gradle.ktlint")
             }
         }
 

build-logic/convention/src/main/java/com/threegap/bitnagil/convention/KotlinParcelizePlugin.kt

@@ -0,0 +1,10 @@
+package com.threegap.bitnagil.convention
+
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+
+class KotlinParcelizePlugin : Plugin<Project> {
+    override fun apply(target: Project): Unit = with(target) {
+        pluginManager.apply("org.jetbrains.kotlin.plugin.parcelize")
+    }
+}

build-logic/convention/src/main/java/com/threegap/bitnagil/convention/KotlinSerializationPlugin.kt

@@ -0,0 +1,16 @@
+package com.threegap.bitnagil.convention
+
+import com.threegap.bitnagil.convention.extension.libs
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.dependencies
+
+class KotlinSerializationPlugin : Plugin<Project> {
+    override fun apply(target: Project): Unit = with(target) {
+        pluginManager.apply("org.jetbrains.kotlin.plugin.serialization")
+
+        dependencies {
+            "implementation"(libs.findLibrary("kotlinx-serialization-json").get())
+        }
+    }
+}

build-logic/convention/src/main/java/com/threegap/bitnagil/convention/extension/AppVersion.kt

@@ -1,37 +1,18 @@
 package com.threegap.bitnagil.convention.extension
 
 import com.android.build.api.dsl.ApplicationExtension
-import com.android.build.api.dsl.LibraryExtension
 import org.gradle.api.Project
-import org.gradle.api.artifacts.VersionCatalogsExtension
-import org.gradle.kotlin.dsl.findByType
-import org.gradle.kotlin.dsl.getByType
 
-internal fun Project.configureAppVersion() {
-    val libs = extensions.getByType<VersionCatalogsExtension>().named("libs")
+internal fun Project.configureAppVersion(extension: ApplicationExtension) {
     val major = libs.findVersion("versionMajor").get().requiredVersion
     val minor = libs.findVersion("versionMinor").get().requiredVersion
     val patch = libs.findVersion("versionPatch").get().requiredVersion
 
-    extensions.findByType<ApplicationExtension>()?.let { appExtension ->
-        appExtension.defaultConfig {
-            versionName = "$major.$minor.$patch"
-            buildConfigField("int", "VERSION_MAJOR", major)
-            buildConfigField("int", "VERSION_MINOR", minor)
-            buildConfigField("int", "VERSION_PATCH", patch)
-        }
-    }
-
-    extensions.findByType<LibraryExtension>()?.let { libExtension ->
-        libExtension.apply {
-            defaultConfig {
-                buildConfigField("int", "VERSION_MAJOR", major)
-                buildConfigField("int", "VERSION_MINOR", minor)
-                buildConfigField("int", "VERSION_PATCH", patch)
-            }
-            buildFeatures {
-                buildConfig = true
-            }
-        }
+    extension.defaultConfig {
+        versionCode = libs.findVersion("versionCode").get().requiredVersion.toInt()
+        versionName = "$major.$minor.$patch"
+        buildConfigField("int", "VERSION_MAJOR", major)
+        buildConfigField("int", "VERSION_MINOR", minor)
+        buildConfigField("int", "VERSION_PATCH", patch)
     }
 }

build-logic/convention/src/main/java/com/threegap/bitnagil/convention/extension/ComposeAndroid.kt

@@ -2,28 +2,24 @@ package com.threegap.bitnagil.convention.extension
 
 import com.android.build.api.dsl.CommonExtension
 import org.gradle.api.Project
-import org.gradle.api.artifacts.VersionCatalogsExtension
-import org.gradle.kotlin.dsl.getByType
 import org.gradle.kotlin.dsl.dependencies
+import org.gradle.kotlin.dsl.getByType
 import org.jetbrains.kotlin.compose.compiler.gradle.ComposeCompilerGradlePluginExtension
 
-internal fun Project.configureComposeAndroid(commonExtension: CommonExtension<*, *, *, *, *, *>) {
-    val libs = extensions.getByType<VersionCatalogsExtension>().named("libs")
-
+internal fun Project.configureComposeAndroid(commonExtension: CommonExtension) {
     commonExtension.apply {
-        buildFeatures {
-            compose = true
-        }
+        buildFeatures.apply { compose = true }
+    }
 
-        extensions.getByType<ComposeCompilerGradlePluginExtension>().apply {
-            includeSourceInformation.set(true)
-        }
+    extensions.getByType<ComposeCompilerGradlePluginExtension>().apply {
+        includeSourceInformation.set(true)
+    }
 
-        dependencies {
-            "implementation"(platform(libs.findLibrary("compose.bom").get()))
-            "implementation"(libs.findBundle("compose").get())
-            "implementation"(libs.findBundle("compose.lifecycle").get())
-            "debugImplementation"(libs.findBundle("compose.debug").get())
-        }
+    dependencies {
+        "implementation"(platform(libs.findLibrary("compose.bom").get()))
+        "implementation"(libs.findBundle("compose").get())
+        "implementation"(libs.findBundle("compose.lifecycle").get())
+        "debugImplementation"(libs.findBundle("compose.debug").get())
     }
+
 }

build-logic/convention/src/main/java/com/threegap/bitnagil/convention/extension/Extensions.kt

@@ -0,0 +1,15 @@
+package com.threegap.bitnagil.convention.extension
+
+import org.gradle.api.Project
+import org.gradle.api.artifacts.VersionCatalog
+import org.gradle.api.artifacts.VersionCatalogsExtension
+import org.gradle.kotlin.dsl.getByType
+
+internal val Project.libs: VersionCatalog
+    get() = extensions.getByType<VersionCatalogsExtension>().named("libs")
+
+internal val Project.basePackage: String
+    get() = libs.findVersion("applicationId").get().requiredVersion
+
+internal val Project.namespace: String
+    get() = if (path == ":app") basePackage else "$basePackage.${name.replace("-", "_")}"