Android多模块项目：集中管理Android块与依赖的方案及报错解决

在Gradle 8.2.1 + AGP 8.0.2环境下，用apply from导入KTS脚本时，脚本执行顺序会导致Android插件的android扩展未完成初始化，直接编写android{}块会触发报错。以下是适配KTS特性的简洁解决方案，分别实现应用/库的Android配置集中管理、依赖集中复用。

一、集中管理应用/库的android{}块 #

最优方案：用buildSrc实现预编译脚本插件 #

buildSrc下的代码会提前编译，能直接访问AGP的API，从根源避免扩展未初始化的问题。

1. 配置buildSrc的build.gradle.kts，引入AGP和Gradle依赖：

plugins {
    `kotlin-dsl`
}

repositories {
    google()
    mavenCentral()
}

dependencies {
    implementation("com.android.tools.build:gradle:8.0.2")
    implementation(kotlin("gradle-plugin", version = "1.9.0"))
    implementation(gradleApi())
}

2. 在buildSrc/src/main/kotlin下创建应用配置插件：AndroidAppConventionsPlugin.kt

import org.gradle.api.Plugin
import org.gradle.api.Project
import com.android.build.api.dsl.ApplicationExtension

class AndroidAppConventionsPlugin : Plugin<Project> {
    override fun apply(target: Project) {
        with(target) {
            pluginManager.apply("com.android.application")
            pluginManager.apply("org.jetbrains.kotlin.android")
            
            extensions.configure<ApplicationExtension> {
                compileSdk = 34
                defaultConfig {
                    minSdk = 21
                    targetSdk = 34
                    versionCode = 1
                    versionName = "1.0"
                    testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
                }
                buildTypes {
                    release {
                        isMinifyEnabled = false
                        proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro")
                    }
                }
                compileOptions {
                    sourceCompatibility = JavaVersion.VERSION_17
                    targetCompatibility = JavaVersion.VERSION_17
                }
                kotlinOptions {
                    jvmTarget = "17"
                }
            }
        }
    }
}

// 注册便捷调用入口
fun Project.androidAppConventions() {
    pluginManager.apply(AndroidLibConventionsPlugin::class.java)
}

3. 同理创建库配置插件：AndroidLibConventionsPlugin.kt

import org.gradle.api.Plugin
import org.gradle.api.Project
import com.android.build.api.dsl.LibraryExtension

class AndroidLibConventionsPlugin : Plugin<Project> {
    override fun apply(target: Project) {
        with(target) {
            pluginManager.apply("com.android.library")
            pluginManager.apply("org.jetbrains.kotlin.android")
            
            extensions.configure<LibraryExtension> {
                compileSdk = 34
                defaultConfig {
                    minSdk = 21
                    testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
                    consumerProguardFiles("consumer-rules.pro")
                }
                buildTypes {
                    release {
                        isMinifyEnabled = false
                        proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro")
                    }
                }
                compileOptions {
                    sourceCompatibility = JavaVersion.VERSION_17
                    targetCompatibility = JavaVersion.VERSION_17
                }
                kotlinOptions {
                    jvmTarget = "17"
                }
            }
        }
    }
}

// 注册便捷调用入口
fun Project.androidLibConventions() {
    pluginManager.apply(AndroidLibConventionsPlugin::class.java)
}

4. 项目模块中引用配置（以app模块为例）：

plugins {
    id("com.android.application")
    id("org.jetbrains.kotlin.android")
}

// 调用预编译插件完成通用配置
androidAppConventions()

// 模块专属配置可在此补充
android {
    namespace = "com.example.myapp"
}

二、集中管理可复用的dependencies{}块 #

方案：buildSrc中定义依赖常量+扩展函数 #

1. 在buildSrc/src/main/kotlin下创建Dependencies.kt：

object Versions {
    const val CORE_KTX = "1.12.0"
    const val APP_COMPAT = "1.6.1"
    const val MATERIAL = "1.11.0"
    const val JUNIT = "4.13.2"
    const val ANDROIDX_JUNIT = "1.1.5"
    const val ESPRESSO_CORE = "3.5.1"
}

object Dependencies {
    // AndroidX基础依赖
    const val CORE_KTX = "androidx.core:core-ktx:${Versions.CORE_KTX}"
    const val APP_COMPAT = "androidx.appcompat:appcompat:${Versions.APP_COMPAT}"
    const val MATERIAL = "com.google.android.material:material:${Versions.MATERIAL}"
    
    // 测试依赖
    const val JUNIT = "junit:junit:${Versions.JUNIT}"
    const val ANDROIDX_JUNIT = "androidx.test.ext:junit:${Versions.ANDROIDX_JUNIT}"
    const val ESPRESSO_CORE = "androidx.test.espresso:espresso-core:${Versions.ESPRESSO_CORE}"
}

// 封装通用依赖添加逻辑
fun Project.addCommonAndroidDependencies() {
    dependencies {
        "implementation"(Dependencies.CORE_KTX)
        "implementation"(Dependencies.APP_COMPAT)
        "implementation"(Dependencies.MATERIAL)
        
        "testImplementation"(Dependencies.JUNIT)
        "androidTestImplementation"(Dependencies.ANDROIDX_JUNIT)
        "androidTestImplementation"(Dependencies.ESPRESSO_CORE)
    }
}

2. 项目模块中引用依赖：

dependencies {
    // 添加通用依赖
    addCommonAndroidDependencies()
    
    // 模块专属依赖在此补充
    implementation("com.squareup.retrofit2:retrofit:2.9.0")
}

备选方案（兼容apply from方式） #

如果坚持使用原有的apply from导入脚本，需在配置脚本中用afterEvaluate延迟执行Android配置，确保插件初始化完成：
在common-app-config.gradle.kts中：

afterEvaluate {
    android {
        compileSdk = 34
        // 其他Android配置...
    }
}

此方案缺乏类型安全校验，仅作为临时兼容方案，优先推荐buildSrc预编译插件方案。

内容的提问来源于stack exchange，提问作者AndroidRocks