为多模块Android项目创建可维护的Gradle脚本

// settings.gradle (root)
include ':app', ':core', ':feature-auth', ':feature-dashboard', ':data', ':domain'

// 传统Groovy方式（无类型安全）
android {
    compileSdkVersion 30
}

// Kotlin DSL方式（类型安全）
android {
    compileSdk = 30
}

dependencies {
    implementation(libs.androidx.core.ktx)
    implementation(libs.androidx.compose.ui)
    testImplementation(libs.junit)
    
    // 模块依赖
    implementation(project(":core"))
    implementation(project(":feature-auth"))
}

// buildSrc/build.gradle.kts
plugins {
    `java-gradle-plugin`
    `kotlin-dsl`
    id("maven-publish")
}

repositories {
    google()
    mavenCentral()
    gradlePluginPortal()
}

dependencies {
    implementation("com.android.tools.build:gradle:8.1.0")
    implementation("org.jetbrains.kotlin:kotlin-gradle-plugin:1.8.20")
    implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8:1.8.20")
}

gradlePlugin {
    plugins {
        register("android-app-plugin") {
            id = "android-app-plugin"
            implementationClass = "AndroidAppPlugin"
        }
        register("android-library-plugin") {
            id = "android-library-plugin"
            implementationClass = "AndroidLibraryPlugin"
        }
    }
}

// settings.gradle.kts
includeBuild("buildSrc")

// buildSrc/src/main/kotlin/AndroidAppPlugin.kt
import com.android.build.api.dsl.ApplicationExtension
import org.gradle.api.Plugin
import org.gradle.api.Project
import org.gradle.kotlin.dsl.configure

class AndroidAppPlugin : Plugin<Project> {
    override fun apply(project: Project) = with(project) {
        with(pluginManager) {
            apply("com.android.application")
            apply("org.jetbrains.kotlin.android")
        }
        
        extensions.configure<ApplicationExtension> {
            configureAndroidCommonSettings(this)
            configureApplicationSpecificSettings(this)
        }
        
        configureDependencies()
    }
    
    private fun configureApplicationSpecificSettings(extension: ApplicationExtension) {
        extension.defaultConfig {
            applicationId = "com.example.myapp"
            versionCode = 1
            versionName = "1.0.0"
            
            // 配置自定义字段
            buildConfigField("String", "API_BASE_URL", "\"https://api.example.com\"")
            buildConfigField("boolean", "LOGGING_ENABLED", "true")
        }
        
        extension.buildTypes {
            getByName("debug") {
                isDebuggable = true
                isMinifyEnabled = false
                applicationIdSuffix = ".debug"
            }
            
            getByName("release") {
                isDebuggable = false
                isMinifyEnabled = true
                isShrinkResources = true
                proguardFiles(
                    getDefaultProguardFile("proguard-android-optimize.txt"),
                    "proguard-rules.pro"
                )
            }
            
            create("staging") {
                initWith(getByName("debug"))
                applicationIdSuffix = ".staging"
                matchingFallbacks += "debug"
            }
        }
        
        extension.productFlavors {
            create("free") {
                dimension = "version"
                applicationIdSuffix = ".free"
                versionNameSuffix = "-free"
            }
            create("paid") {
                dimension = "version"
                applicationIdSuffix = ".paid"
                versionNameSuffix = "-paid"
            }
        }
    }
    
    private fun Project.configureDependencies() {
        dependencies.run {
            // 公共依赖
            add("implementation", libs.androidx.core.ktx)
            add("implementation", libs.androidx.appcompat)
            add("implementation", libs.material)
            
            // 测试依赖
            add("testImplementation", libs.junit)
            add("androidTestImplementation", libs.androidx.junit)
            add("androidTestImplementation", libs.androidx.espresso.core)
        }
    }
}

// buildSrc/src/main/kotlin/AndroidLibraryPlugin.kt
import com.android.build.api.dsl.LibraryExtension
import org.gradle.api.Plugin
import org.gradle.api.Project
import org.gradle.kotlin.dsl.configure

class AndroidLibraryPlugin : Plugin<Project> {
    override fun apply(project: Project) = with(project) {
        with(pluginManager) {
            apply("com.android.library")
            apply("org.jetbrains.kotlin.android")
        }
        
        extensions.configure<LibraryExtension> {
            configureAndroidCommonSettings(this)
            configureLibrarySpecificSettings(this)
        }
        
        configureDependencies()
    }
    
    private fun configureLibrarySpecificSettings(extension: LibraryExtension) {
        extension.buildTypes {
            getByName("debug") {
                isMinifyEnabled = false
            }
            
            getByName("release") {
                isMinifyEnabled = true
                consumerProguardFiles("proguard-rules.pro")
            }
        }
        
        // 配置发布选项
        extension.publishing {
            singleVariant("release") {
                withSourcesJar()
                withJavadocJar()
            }
        }
    }
    
    private fun Project.configureDependencies() {
        dependencies.run {
            // 公共依赖
            add("implementation", libs.androidx.core.ktx)
            
            // 测试依赖
            add("testImplementation", libs.junit)
            add("androidTestImplementation", libs.androidx.junit)
        }
    }
}

// 公共Android配置扩展函数
fun configureAndroidCommonSettings(extension: CommonExtension<*>) {
    extension.compileSdk = 34
    
    extension.defaultConfig {
        minSdk = 24
        targetSdk = 34
        
        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
        
        // 公共ProGuard配置
        consumerProguardFiles("consumer-rules.pro")
    }
    
    extension.compileOptions {
        sourceCompatibility = JavaVersion.VERSION_11
        targetCompatibility = JavaVersion.VERSION_11
    }
    
    extension.kotlinOptions {
        jvmTarget = "11"
        freeCompilerArgs = freeCompilerArgs + listOf(
            "-Xopt-in=kotlin.RequiresOptIn",
            "-Xjvm-default=all"
        )
    }
    
    extension.buildFeatures {
        compose = true
        buildConfig = true
    }
    
    extension.composeOptions {
        kotlinCompilerExtensionVersion = "1.5.1"
    }
    
    extension.packagingOptions {
        resources {
            excludes += "/META-INF/{AL2.0,LGPL2.1}"
            excludes += "META-INF/LICENSE.md"
            excludes += "META-INF/LICENSE-notice.md"
        }
    }
}

// app/build.gradle.kts
plugins {
    id("android-app-plugin")
}

android {
    namespace = "com.example.myapp"
    
    // 可以覆盖插件中的默认配置
    defaultConfig {
        versionCode = 2
        versionName = "1.0.1"
    }
}

dependencies {
    // 添加模块特定依赖
    implementation(project(":core"))
    implementation(project(":feature-auth"))
    implementation(project(":feature-dashboard"))
    
    // 添加模块特定第三方依赖
    implementation(libs.retrofit)
    implementation(libs.okhttp.logging)
}

// feature-auth/build.gradle.kts
plugins {
    id("android-library-plugin")
}

android {
    namespace = "com.example.feature.auth"
}

dependencies {
    implementation(project(":core"))
    implementation(libs.androidx.compose.ui)
    implementation(libs.koin.android)
}

// 在build.gradle.kts中使用版本目录
dependencies {
    // 使用单个依赖
    implementation(libs.androidx.core.ktx)
    implementation(libs.retrofit)
    
    // 使用依赖包
    implementation(libs.bundles.androidx.compose)
    implementation(libs.bundles.network)
    
    // 测试依赖
    testImplementation(libs.junit)
    androidTestImplementation(libs.bundles.androidx.test)
}

// 扩展函数用于访问版本目录
fun Project.getLibs(): VersionCatalog {
    return extensions.getByType<VersionCatalogsExtension>().named("libs")
}

// 在插件中使用版本目录
class AndroidAppPlugin : Plugin<Project> {
    override fun apply(project: Project) = with(project) {
        val libs = getLibs()
        
        extensions.configure<ApplicationExtension> {
            defaultConfig {
                minSdk = libs.findVersion("minSdk").get().requiredVersion.toInt()
                targetSdk = libs.findVersion("targetSdk").get().requiredVersion.toInt()
            }
        }
        
        dependencies.apply {
            add("implementation", libs.findLibrary("androidx.core.ktx").get())
            add("implementation", libs.findLibrary("androidx.compose.ui").get())
        }
    }
}

android {
    flavorDimensions += listOf("version", "environment")
    
    productFlavors {
        create("free") {
            dimension = "version"
            applicationIdSuffix = ".free"
        }
        create("paid") {
            dimension = "version"
            applicationIdSuffix = ".paid"
        }
        
        create("dev") {
            dimension = "environment"
            buildConfigField("String", "API_URL", "\"https://dev.api.example.com\"")
        }
        create("staging") {
            dimension = "environment"
            buildConfigField("String", "API_URL", "\"https://staging.api.example.com\"")
        }
        create("prod") {
            dimension = "environment"
            buildConfigField("String", "API_URL", "\"https://api.example.com\"")
        }
    }
    
    // 配置变体过滤器
    variantFilter {
        ignore = buildType.name == "release" && 
                flavors.any { it.name == "dev" }
    }
    
    // 配置源集
    sourceSets {
        getByName("freeDev") {
            java.srcDirs("src/free/java")
        }
        getByName("paidProd") {
            res.srcDirs("src/paid/res")
        }
    }
}

// gradle.properties中配置构建优化
org.gradle.parallel=true
org.gradle.caching=true
org.gradle.daemon=true
org.gradle.configureondemand=true
android.enableBuildCache=true

# 内存配置
org.gradle.jvmargs=-Xmx4096m -XX:MaxMetaspaceSize=1024m -XX:+HeapDumpOnOutOfMemoryError
kotlin.code.style=official

# 构建性能监控
org.gradle.console=verbose

class BuildOptimizationPlugin : Plugin<Project> {
    override fun apply(project: Project) = with(project) {
        // 配置增量构建
        tasks.withType<JavaCompile>().configureEach {
            options.isIncremental = true
        }
        
        // 配置并行编译
        tasks.withType<KotlinCompile>().configureEach {
            kotlinOptions {
                jvmTarget = "11"
                freeCompilerArgs = freeCompilerArgs + listOf(
                    "-Xopt-in=kotlin.RequiresOptIn",
                    "-Xjvm-default=all",
                    "-Xskip-prerelease-check"
                )
            }
        }
        
        // 配置R8优化
        extensions.configure<ApplicationExtension> {
            buildTypes {
                getByName("release") {
                    isCrunchPngs = true
                    isShrinkResources = true
                    isMinifyEnabled = true
                }
            }
        }
        
        // 配置资源优化
        afterEvaluate {
            android?.run {
                packagingOptions {
                    resources {
                        excludes += setOf(
                            "META-INF/*.kotlin_module",
                            "META-INF/*.version",
                            "META-INF/proguard/*",
                            "META-INF/licenses/*",
                            "**/DebugProbesKt.bin",
                            "**/*.proto"
                        )
                        pickFirsts += setOf(
                            "**/libc++_shared.so",
                            "**/libfbjni.so"
                        )
                    }
                }
            }
        }
    }
}

android {
    testOptions {
        unitTests {
            isIncludeAndroidResources = true
            isReturnDefaultValues = true
            
            all {
                it.jvmArgs("-noverify", "-XX:+UseParallelGC")
                it.minHeapSize = "128m"
                it.maxHeapSize = "512m"
                it.forkEvery = 100
            }
        }
        
        execution = "ANDROIDX_TEST_ORCHESTRATOR"
        
        animationsDisabled = true
    }
}

// 配置模块特定测试任务
tasks.register<Test>("unitTest") {
    group = "verification"
    description = "Runs all unit tests in all modules"
    
    dependsOn(gradle.includedBuilds.flatMap { 
        it.task(":test") 
    })
}

tasks.register<Test>("androidTest") {
    group = "verification"
    description = "Runs all Android tests in all modules"
    
    dependsOn(gradle.includedBuilds.flatMap { 
        it.task(":connectedAndroidTest") 
    })
}

dependencies {
    // 添加依赖约束
    constraints {
        implementation("com.google.guava:guava") {
            version { strictly("32.1.2-jre") }
            because("Security fix in later versions")
        }
        
        implementation("com.squareup.okhttp3:okhttp") {
            version { require("4.11.0") }
            because("API compatibility with our codebase")
        }
    }
    
    // 排除传递性依赖
    implementation("com.example:library:1.0") {
        exclude(group = "com.unwanted", module = "library")
        exclude(module = "another-unwanted")
    }
    
    // 强制使用特定版本
    configurations.all {
        resolutionStrategy {
            force(
                "androidx.core:core-ktx:1.10.1",
                "org.jetbrains.kotlin:kotlin-stdlib:1.8.20"
            )
            
            // 依赖替换
            substitute(module("com.old:library"))
                .using(module("com.new:library:2.0"))
                .because("The old library was deprecated")
            
            // 缓存配置
            cacheDynamicVersionsFor(10, TimeUnit.MINUTES)
            cacheChangingModulesFor(4, TimeUnit.HOURS)
        }
    }
}

dependencies {
    // 导入Compose BOM
    implementation(platform(libs.androidx.compose.bom))
    
    // 不需要指定版本，版本由BOM管理
    implementation(libs.androidx.compose.ui)
    implementation(libs.androidx.compose.ui.tooling)
    implementation(libs.androidx.compose.material3)
    
    // Firebase BOM
    implementation(platform("com.google.firebase:firebase-bom:32.2.2"))
    implementation("com.google.firebase:firebase-analytics")
    implementation("com.google.firebase:firebase-crashlytics")
}

// 创建CI专用配置文件
// ci.gradle.kts
tasks.register("ciBuild") {
    group = "CI"
    description = "Runs all checks required for CI"
    
    dependsOn(
        ":app:assembleRelease",
        ":app:lintRelease",
        ":test",
        ":androidTest",
        ":dependencyCheck"
    )
}

tasks.register("dependencyCheck") {
    group = "CI"
    description = "Checks for outdated dependencies"
    
    doLast {
        exec {
            commandLine("./gradlew", "dependencyUpdates", "-Drevision=release")
        }
    }
}

// 配置签名信息
signingConfigs {
    create("ciSigning") {
        storeFile = file(System.getenv("KEYSTORE_PATH") ?: "debug.keystore")
        storePassword = System.getenv("KEYSTORE_PASSWORD") ?: "android"
        keyAlias = System.getenv("KEY_ALIAS") ?: "androiddebugkey"
        keyPassword = System.getenv("KEY_PASSWORD") ?: "android"
    }
}

// 配置构建缓存
buildCache {
    local {
        directory = File(rootDir, "build-cache")
        removeUnusedEntriesAfterDays = 7
    }
    
    remote<HttpBuildCache> {
        url = uri("https://ci.example.com/cache/")
        credentials {
            username = System.getenv("CACHE_USER")
            password = System.getenv("CACHE_PASSWORD")
        }
        push = System.getenv("CI") == "true"
    }
}

// 构建分析插件
class BuildAnalysisPlugin : Plugin<Project> {
    override fun apply(project: Project) = with(project) {
        // 注册构建扫描任务
        tasks.register("analyzeBuild") {
            group = "verification"
            description = "Analyzes build performance and generates report"
            
            doLast {
                exec {
                    commandLine("./gradlew", "build", "--scan", "--no-daemon")
                }
            }
        }
        
        // 配置构建监听
        gradle.buildFinished {
            val buildDuration = it.result?.endTime?.minus(it.result?.startTime ?: 0) ?: 0
            println("Build completed in ${buildDuration}ms")
            
            if (buildDuration > 120000) { // 2分钟
                logger.warn("Build time exceeds threshold. Consider optimizing your build configuration.")
            }
        }
        
        // 任务时间监控
        tasks.configureEach {
            doFirst {
                logger.lifecycle("Starting task: ${this.name}")
            }
            
            doLast {
                logger.lifecycle("Completed task: ${this.name}")
            }
        }
    }
}

// 配置Gradle企业版进行高级分析
// settings.gradle.kts
plugins {
    id("com.gradle.enterprise").version("3.12.6")
}

gradleEnterprise {
    buildScan {
        termsOfServiceUrl = "https://gradle.com/terms-of-service"
        termsOfServiceAgree = "yes"
        
        publishAlways()
        uploadInBackground = !System.getenv("CI").toBoolean()
        
        background {
            customValue("CI", System.getenv("CI") ?: "false")
            customValue("OS", System.getProperty("os.name"))
            customValue("Java Version", System.getProperty("java.version"))
        }
    }
}

// 配置Detekt静态代码分析
plugins {
    id("io.gitlab.arturbosch.detekt").version("1.23.0")
}

detekt {
    toolVersion = "1.23.0"
    config = files("$rootDir/config/detekt/detekt.yml")
    buildUponDefaultConfig = true
    
    autoCorrect = true
}

tasks.withType<io.gitlab.arturbosch.detekt.Detekt>().configureEach {
    reports {
        html.required.set(true)
        xml.required.set(true)
        txt.required.set(true)
    }
}

// 配置Spotless代码格式化
plugins {
    id("com.diffplug.spotless").version("6.19.0")
}

spotless {
    kotlin {
        target("**/*.kt")
        ktlint("0.48.2")
        licenseHeaderFile("$rootDir/config/license-header.txt")
    }
    
    kotlinGradle {
        target("**/*.gradle.kts")
        ktlint("0.48.2")
    }
}

// 创建文档生成任务
tasks.register("generateBuildDocs") {
    group = "documentation"
    description = "Generates documentation for the build system"
    
    doLast {
        val docsDir = file("$rootDir/docs/build-system")
        docsDir.mkdirs()
        
        // 生成模块依赖图
        exec {
            commandLine("./gradlew", ":app:dependencies", "--configuration", "releaseRuntimeClasspath")
        }
        
        // 生成任务文档
        file("$docsDir/tasks.md").writeText("# Build Tasks\n\n")
        tasks.forEach { task ->
            file("$docsDir/tasks.md").appendText("## ${task.name}\n\n")
            file("$docsDir/tasks.md").appendText("**Group**: ${task.group}\n\n")
            file("$docsDir/tasks.md").appendText("**Description**: ${task.description}\n\n")
        }
    }
}

// 配置预提交钩子
tasks.register("installGitHooks") {
    group = "development"
    description = "Installs Git hooks for code quality checks"
    
    doLast {
        val hooksDir = rootProject.file(".git/hooks")
        val preCommitHook = File(hooksDir, "pre-commit")
        
        preCommitHook.writeText("""
            #!/bin/bash
            ./gradlew spotlessCheck detekt
            if [ \$? -ne 0 ]; then
                echo "Code quality checks failed. Please fix the issues before committing."
                exit 1
            fi
        """.trimIndent())
        
        preCommitHook.setExecutable(true)
    }
}