Add precompiled plugin

app/build.gradle.kts

@@ -1,49 +1,12 @@
 plugins {
-    alias(libs.plugins.android.application)
-    alias(libs.plugins.kotlin.android)
+    id("com.ujizin.android-application")
     id(libs.plugins.google.services.get().pluginId)
     id(libs.plugins.google.crashlytics.get().pluginId)
 }
 
-apply(from = "$rootDir/config-android.gradle")
-apply(from = "$rootDir/config-compose.gradle")
-
-android {
-    namespace = "com.ujizin.leafy"
-    defaultConfig {
-        applicationId = "com.ujizin.leafy"
-        versionCode = 1
-        versionName = "0.1.0"
-    }
-
-    signingConfigs {
-        create("release") {
-            storeFile = file("${rootProject.extra["RELEASE_STORE_FILE"]}")
-            storePassword = "${rootProject.extra["RELEASE_STORE_PASSWORD"]}"
-            keyAlias = "${rootProject.extra["RELEASE_KEY_ALIAS"]}"
-            keyPassword = "${rootProject.extra["RELEASE_KEY_PASSWORD"]}"
-        }
-    }
-
-    buildTypes {
-        getByName("release") {
-            isMinifyEnabled = false
-            resValue("string", "app_name", "Leafy")
-            signingConfig = signingConfigs.getByName("release")
-        }
-
-        getByName("debug") {
-            isMinifyEnabled = false
-            applicationIdSuffix = ".debug"
-            versionNameSuffix = "-debug"
-            resValue("string", "app_name", "Leafy Dev")
-        }
-    }
-}
+android { namespace = "com.ujizin.leafy" }
 
 dependencies {
-    implementation(libs.androidx.core.splashscreen)
-
     implementation(projects.features.home)
     implementation(projects.features.search)
     implementation(projects.features.alarm)
@@ -60,7 +23,4 @@ dependencies {
     implementation(projects.core.ui)
     implementation(projects.core.themes)
     implementation(projects.core.navigation)
-
-    androidTestImplementation(libs.bundles.test)
-    androidTestImplementation(libs.bundles.androidx.test)
 }

app/src/main/java/com/ujizin/leafy/AppConfiguration.kt

@@ -15,9 +15,7 @@ import com.ujizin.leafy.user.rememberUserState
 import com.ujizin.leafy.user.setLanguage
 
 @Composable
-fun AppCompatActivity.AppConfiguration(
-    content: @Composable Content,
-) {
+fun AppCompatActivity.AppConfiguration(content: @Composable Content) {
     val userState by rememberUserState()
     when (val state: MainUiState = userState) {
         is MainUiState.Initialized -> {

app/src/main/java/com/ujizin/leafy/BackHandler.kt

@@ -9,20 +9,14 @@ import androidx.navigation.NavHostController
 import kotlinx.coroutines.launch
 
 @Composable
-fun BackHandler(
-    navController: NavHostController,
-    drawerState: DrawerState,
-    onFinish: () -> Unit,
-) {
+fun BackHandler(navController: NavHostController, drawerState: DrawerState, onFinish: () -> Unit) {
     val scope = rememberCoroutineScope()
     val isDrawerOpen by rememberUpdatedState(drawerState.isOpen)
 
     when {
-        isDrawerOpen -> androidx.activity.compose.BackHandler {
-            scope.launch { drawerState.close() }
-        }
-        else -> androidx.activity.compose.BackHandler {
-            if (!navController.navigateUp()) onFinish()
-        }
+        isDrawerOpen ->
+            androidx.activity.compose.BackHandler { scope.launch { drawerState.close() } }
+        else ->
+            androidx.activity.compose.BackHandler { if (!navController.navigateUp()) onFinish() }
     }
 }

app/src/main/java/com/ujizin/leafy/LeafyApplication.kt

@@ -8,8 +8,7 @@ import javax.inject.Inject
 @HiltAndroidApp
 class LeafyApplication : Application() {
 
-    @Inject
-    lateinit var alarmNotificator: AlarmNotificator
+    @Inject lateinit var alarmNotificator: AlarmNotificator
 
     override fun onCreate() {
         super.onCreate()

app/src/main/java/com/ujizin/leafy/LeafyNavigation.kt

@@ -27,31 +27,19 @@ import com.ujizin.leafy.search.searchGraph
 import kotlinx.coroutines.launch
 
 @Composable
-fun LeafyNavigation(
-    navController: NavHostController,
-    drawerState: DrawerState,
-) {
+fun LeafyNavigation(navController: NavHostController, drawerState: DrawerState) {
     val scope = rememberCoroutineScope()
     ScaffoldWithDrawer(
-        modifier = Modifier
-            .imePadding()
-            .navigationBarsPadding(),
+        modifier = Modifier.imePadding().navigationBarsPadding(),
         drawerState = drawerState,
         navController = navController,
     ) {
-        NavHost(
-            navController = navController,
-            startDestination = Destination.Home,
-        ) {
+        NavHost(navController = navController, startDestination = Destination.Home) {
             homeGraph(
                 enterTransition = { navigationEnterTransition(navController) },
-                exitTransition = {
-                    navigationExitTransition(navController).orNone
-                },
+                exitTransition = { navigationExitTransition(navController).orNone },
                 onTakePictureClick = { navController.navigate(Destination.Camera) },
-                onSearchClick = {
-                    navController.navigate(Destination.Search(true))
-                },
+                onSearchClick = { navController.navigate(Destination.Search(true)) },
                 onDrawerClick = { scope.launch { drawerState.open() } },
                 onPlantClick = { plantId ->
                     navController.navigate(Destination.PlantDetails(plantId))

app/src/main/java/com/ujizin/leafy/MainActivity.kt

@@ -32,10 +32,7 @@ class MainActivity : AppCompatActivity() {
                     onFinish = ::finish,
                 )
 
-                LeafyNavigation(
-                    navController = navController,
-                    drawerState = drawerState,
-                )
+                LeafyNavigation(navController = navController, drawerState = drawerState)
             }
         }
     }

app/src/main/java/com/ujizin/leafy/MainViewModel.kt

@@ -5,17 +5,15 @@ import com.ujizin.leafy.domain.model.User
 import com.ujizin.leafy.domain.result.Result
 import com.ujizin.leafy.domain.usecase.user.load.LoadUserUseCase
 import dagger.hilt.android.lifecycle.HiltViewModel
+import javax.inject.Inject
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.map
-import javax.inject.Inject
 
 @HiltViewModel
-class MainViewModel @Inject constructor(
-    private val loadUser: LoadUserUseCase,
-) : ViewModel() {
+class MainViewModel @Inject constructor(private val loadUser: LoadUserUseCase) : ViewModel() {
 
-    fun load(): Flow<MainUiState> = loadUser()
-        .map { result ->
+    fun load(): Flow<MainUiState> =
+        loadUser().map { result ->
             when (result) {
                 is Result.Success -> MainUiState.Initialized(result.data)
                 else -> MainUiState.Loading
@@ -25,5 +23,6 @@ class MainViewModel @Inject constructor(
 
 sealed interface MainUiState {
     data object Loading : MainUiState
+
     data class Initialized(val user: User) : MainUiState
 }

app/src/main/java/com/ujizin/leafy/user/LanguageExtensions.kt

@@ -2,11 +2,10 @@ package com.ujizin.leafy.user
 
 import com.ujizin.leafy.domain.model.Language
 
-/**
- * Get locale by language.
- */
+/** Get locale by language. */
 val Language.tag: String
-    get() = when (this) {
-        Language.PT -> "pt-BR"
-        Language.EN -> "en-US"
-    }
+    get() =
+        when (this) {
+            Language.PT -> "pt-BR"
+            Language.EN -> "en-US"
+        }

app/src/main/java/com/ujizin/leafy/user/UserExtensions.kt

@@ -11,13 +11,9 @@ import java.util.Locale
 
 fun AppCompatActivity.setLanguage(language: Language) {
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-        getSystemService(LocaleManager::class.java)
-            .applicationLocales = LocaleList(
-            Locale.forLanguageTag(language.tag),
-        )
+        getSystemService(LocaleManager::class.java).applicationLocales =
+            LocaleList(Locale.forLanguageTag(language.tag))
     } else {
-        AppCompatDelegate.setApplicationLocales(
-            LocaleListCompat.forLanguageTags(language.tag),
-        )
+        AppCompatDelegate.setApplicationLocales(LocaleListCompat.forLanguageTags(language.tag))
     }
 }

app/src/main/java/com/ujizin/leafy/user/UserState.kt

@@ -11,9 +11,9 @@ import com.ujizin.leafy.domain.model.Theme
 import com.ujizin.leafy.domain.model.User
 
 @Composable
-fun rememberUserState(viewModel: MainViewModel = hiltViewModel()) = remember(viewModel) {
-    viewModel.load()
-}.collectAsStateWithLifecycle(initialValue = MainUiState.Loading)
+fun rememberUserState(viewModel: MainViewModel = hiltViewModel()) =
+    remember(viewModel) { viewModel.load() }
+        .collectAsStateWithLifecycle(initialValue = MainUiState.Loading)
 
 @Composable
 fun User.isUserInDarkTheme(): Boolean {

build.gradle.kts

@@ -10,19 +10,8 @@ buildscript {
 }
 
 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.hilt) apply false
-    alias(libs.plugins.ksp) apply false
     alias(libs.plugins.kotlinx.serialization)
     alias(libs.plugins.detekt)
-    alias(libs.plugins.spotless)
-}
-
-subprojects {
-    apply(plugin = rootProject.libs.plugins.spotless.get().pluginId)
-    apply(from = "${project.rootDir}/spotless.gradle")
 }
 
 detekt {

buildSrc/build.gradle.kts

@@ -0,0 +1,21 @@
+plugins {
+    `kotlin-dsl`
+    `kotlin-dsl-precompiled-script-plugins`
+}
+
+repositories {
+    mavenCentral()
+    google()
+    gradlePluginPortal()
+}
+
+dependencies {
+    implementation(gradleApi())
+    implementation(libs.gradle.plugin)
+    implementation(libs.kotlin.gradle.plugin)
+    implementation(libs.gradle.api.plugin)
+    implementation(libs.kfmt.plugin)
+    implementation(libs.spotless.plugin.gradle)
+    implementation(libs.hilt.plugin)
+    implementation(libs.ksp.plugin)
+}

buildSrc/settings.gradle.kts

@@ -0,0 +1,7 @@
+dependencyResolutionManagement {
+    versionCatalogs {
+        create("libs") {
+            from(files("../gradle/libs.versions.toml"))
+        }
+    }
+}

buildSrc/src/main/kotlin/com/ujizin/leafy/plugins/com.ujizin.android-application.gradle.kts

@@ -0,0 +1,52 @@
+import com.ujizin.leafy.plugins.utils.configAndroid
+import com.ujizin.leafy.plugins.utils.configApplication
+
+plugins {
+    id("com.android.application")
+    id("kotlin-android")
+    id("org.jetbrains.kotlin.android")
+    id("dagger.hilt.android.plugin")
+    id("com.google.devtools.ksp")
+    id("com.ujizin.code-quality")
+}
+
+internal val Project.libs: VersionCatalog
+    get() = project.extensions.getByType<VersionCatalogsExtension>().named("libs")
+
+apply(from = "$rootDir/config-properties.gradle.kts")
+
+android {
+    configApplication(project)
+    configAndroid()
+    kotlinOptions {
+        jvmTarget = "17"
+    }
+    hilt {
+        enableAggregatingTask = true
+    }
+
+    buildFeatures {
+        compose = true
+    }
+    composeOptions {
+        kotlinCompilerExtensionVersion = libs.findVersion("compose-compiler").get().requiredVersion
+    }
+}
+
+dependencies {
+    implementation(platform(libs.findLibrary("firebase-bom").get()))
+    implementation(libs.findLibrary("firebase-crashlytics-ktx").get())
+    implementation(libs.findLibrary("firebase-analytics-ktx").get())
+
+    implementation(libs.findLibrary("androidx-core-splashscreen").get())
+    implementation(libs.findBundle("androidx").get())
+
+    implementation(platform(libs.findLibrary("compose-bom").get()))
+    implementation(libs.findBundle("compose").get())
+    implementation(libs.findLibrary("hilt-compose").get())
+
+    implementation(libs.findLibrary("hilt").get())
+    ksp(libs.findLibrary("hilt.compiler").get())
+
+    testImplementation(libs.findLibrary("mockk").get())
+}

buildSrc/src/main/kotlin/com/ujizin/leafy/plugins/com.ujizin.android-compose.gradle.kts

@@ -0,0 +1,27 @@
+plugins {
+    id("com.ujizin.android-library")
+}
+
+internal val Project.libs: VersionCatalog
+    get() = project.extensions.getByType<VersionCatalogsExtension>().named("libs")
+
+android {
+    buildFeatures {
+        compose = true
+    }
+
+    composeOptions {
+        kotlinCompilerExtensionVersion = libs.findVersion("compose-compiler").get().requiredVersion
+    }
+}
+
+dependencies {
+    implementation(platform(libs.findLibrary("compose-bom").get()))
+    implementation(libs.findBundle("compose").get())
+    debugImplementation(libs.findBundle("compose-debug").get())
+    androidTestImplementation(libs.findLibrary("compose-android-test").get())
+    implementation(libs.findLibrary("hilt-compose").get())
+
+    implementation(libs.findLibrary("android-material").get())
+    implementation(libs.findBundle("androidx").get())
+}

buildSrc/src/main/kotlin/com/ujizin/leafy/plugins/com.ujizin.android-feature.gradle.kts

@@ -0,0 +1,11 @@
+plugins {
+    id("com.ujizin.android-compose")
+}
+
+dependencies {
+    implementation(project(":core:navigation"))
+    implementation(project(":core:ui"))
+    implementation(project(":core:themes"))
+    testImplementation(project(":core:test"))
+    androidTestImplementation(project(":core:test"))
+}