概述

Gradle的出現(xiàn)可以說是為Android的項目構(gòu)建插上了翅膀，讓Android的apk打包構(gòu)建更簡單高效。開發(fā)者可以自己去定義打包的過程，比如在打包的過程中進(jìn)行字節(jié)碼插樁，多渠道打包，在老版本的Android中還可以依賴Gradle實現(xiàn)APP的插件化開發(fā)。但是Gradle是使用Groovy語言開發(fā)的，雖然說是和JAVA語言差不多，語法啥的差異也不大，但是終究他們兩個還是不同的語言，開發(fā)者要想做Android打包的配置，還需要去了解Groovy語言，這無疑增加了開發(fā)者的負(fù)擔(dān)。

但是由于Oracle公司將Google公司給告了，導(dǎo)致google不得不將Android的官方語言改成Kotlin，這一改，很多開發(fā)者之前可就不開心了，包括我也一樣。但是后面真香定律生效了，Kotlin是真的香。更爽的是Google推出了ComposeUI,讓使用XML寫布局的時代漸行漸遠(yuǎn)了。這讓我特別開心，因為我只需要學(xué)習(xí)Kotlin,一種語言，我就可以進(jìn)行Android開發(fā)了，不需要再去記憶xml中的那些語法了。然后我意識到，構(gòu)建工具還是其他語言呀，要是能都用Kotlin就爽了。然后Google仿佛聽到了我的心聲，推出了基于Kotlin dsl的gradle，也就是說，我們也可以使用Kotlin來編寫Gradle腳本了。真的是爽翻天了呀，然后我就去嘗試了下，真的很爽，依賴管理啥的特別清晰。而且只需要一次定義，然后在很多地方都可以使用，本文就是記錄如何使用Kotlin dsl語言來編寫Android項目的構(gòu)建插件

1.Gradle Kotlin-DSL配置

Android的構(gòu)建產(chǎn)物一般有兩種，一種是APK的形式，直接可以安裝運(yùn)行，另外一種是AAR的形式，作為SDK庫提供給其他應(yīng)用使用。本文會分別介紹這兩種方式的配置和編寫。步驟如下：

1.1 在根目錄下建立一個buildSrc目錄，

這里需要注意的是名字必須是buildSrc，這個目錄是gradle插件的一種方式，也就是這個目錄會被自動參與構(gòu)建，在目錄下面創(chuàng)建出下圖中的包結(jié)構(gòu)和類，準(zhǔn)備開始編寫我們的項目構(gòu)建腳本

1.2.新建build.gradle.kts文件并添加Kotlin dsl相關(guān)配置

要想使用 KotlinDsl，需要我們引入kotlin 的插件，我們在上一步創(chuàng)建的buildSrc目錄下新建build.gradle.kts并引入kotlin相關(guān)的配置，代碼如下：

plugins {
    `kotlin-dsl`
}

repositories {
    google()
    mavenCentral()
}

dependencies {
    implementation("com.android.tools.build:gradle:7.2.2")
    implementation(kotlin("gradle-plugin","1.7.10"))
}

這樣就將Kotlin dsl引入到項目中了，下面我們需要使用Kotlin編寫我們構(gòu)建Android項目時的配置了。

2.Gradle Kotlin DSL 的編寫

在新建完buildSrc目錄和build.gradle.kts文件引入了kotlin dsl的插件后，我們就可以使用Kotlin dsl插件配置構(gòu)建Android項目了，步驟如下：

2.1 定義項目的版本號信息

在構(gòu)建Android項目時，我們需要定義項目的最小支持Android SDK和最大支持的Android SDK，以及編譯使用的SDK等信息，這些信息我們可以在buildSrc目錄下新建一個Version類保存，代碼如下所示：

object Versions {
    const val applicationId = "com.xxx.xxxx" // apk的包名
    const val compileSdkVersion = 33
    const val minSdkVersion = 24
    const val targetSdkVersion = 33
    const val versionCode = 1
    const val versionName = "1.0.0"
}

2.2.定義Dependencies管理項目中需要使用的庫依賴

在之前使用groovy語言定義的依賴中，我們在需要第三方庫或者官方庫的時候，都會去使用 implementation("xxx.xxx.xxx.A庫") 這種方式引入依賴，假設(shè)在項目的另一個Module中也需要使用這個庫，因為是implementation的，所以另一個模塊需要再去引用這個庫，這些都還好，主要是涉及庫的版本更新時不好管理，假設(shè)兩個模塊使用的庫版本不一致，而恰好這兩個版本的庫中的功能做了修改，那么就會導(dǎo)致一個模塊能工作另一個模塊不能工作了，所以將依賴集中到一個地方管理很有必要，下面我們可以使用一個Dependencies類管理我們項目中的所有依賴，代碼如下：

object Dependencies {
    private object DependencieVersions {
        const val kotlin = "1.5.31"
        const val kotlin_coroutines = "1.6.4"
        const val arouter = "1.5.2"
        const val retrofit = "2.9.0"
        const val exoplayer = "2.18.1"
        const val compose_ui_version = "1.3.0"
        const val moshi = "1.13.0"
        const val room = "2.4.3"
    }

    fun getComposeUiVersion(): String {
        return DependencieVersions.compose_ui_version
    }

    object Apache {
        const val commons_net = "commons-net:commons-net:3.7.2"
    }


    object Alibaba {
        const val arouter_api = "com.alibaba:arouter-api:${DependencieVersions.arouter}"
        const val arouter_compiler = "com.alibaba:arouter-compiler:${DependencieVersions.arouter}"
    }

    object AndroidX {
        const val junit_ext = "androidx.test.ext:junit:1.1.1"
        const val espresso = "androidx.test.espresso:espresso-core:3.2.0"
        const val core = "androidx.core:core-ktx:1.8.0"
        const val activity_ktx = "androidx.activity:activity-ktx:1.5.1"
        const val appcompat = "androidx.appcompat:appcompat:1.5.0"
        const val lifecycle_runtime_ktx = "androidx.lifecycle:lifecycle-runtime-ktx:2.3.1"

        const val room_ktx = "androidx.room:room-ktx:${DependencieVersions.room}"
        const val room = "androidx.room:room-runtime:${DependencieVersions.room}"
        const val room_compiler = "androidx.room:room-compiler:${DependencieVersions.room}"
        const val androidx_recyclerview = "androidx.recyclerview:recyclerview:1.3.0"
        const val constraintlayout = "androidx.constraintlayout:constraintlayout:2.1.4"
        const val swiperefreshlayout = "androidx.swiperefreshlayout:swiperefreshlayout:1.1.0"
        const val androidx_collection_ktx = "androidx.collection:collection-ktx:1.2.0"

        const val paging = "androidx.paging:paging-runtime-ktx:3.1.1"
    }

    object ComposeUI {
        const val activity_compose = "androidx.activity:activity-compose:1.3.1"
        const val compose_ui = "androidx.compose.ui:ui:${DependencieVersions.compose_ui_version}"
        const val compose_ui_tooling_preview =
            "androidx.compose.ui:ui-tooling-preview:${DependencieVersions.compose_ui_version}"
        const val compose_material = "androidx.compose.material:material:1.2.0"
        const val compose_ui_test_manifest =
            "androidx.compose.ui:ui-test-manifest:${DependencieVersions.compose_ui_version}"
    }

    object Junit {
        const val junit = "junit:junit:4.12"
    }

    object Kotlin {
        const val lib = "org.jetbrains.kotlin:kotlin-stdlib:${DependencieVersions.kotlin}"
        const val stdlib_jdk7 =
            "org.jetbrains.kotlin:kotlin-stdlib-jdk7:${DependencieVersions.kotlin}"
        const val coroutines_core =
            "org.jetbrains.kotlinx:kotlinx-coroutines-core:${DependencieVersions.kotlin_coroutines}"
        const val coroutines_android =
            "org.jetbrains.kotlinx:kotlinx-coroutines-android:${DependencieVersions.kotlin_coroutines}"
    }


    object Square {
        const val leakcanary = "com.squareup.leakcanary:leakcanary-android:2.9.1"
        const val retrofit = "com.squareup.retrofit2:retrofit:${DependencieVersions.retrofit}"
        const val retrofit_moshi =
            "com.squareup.retrofit2:converter-moshi:${DependencieVersions.retrofit}"
        const val moshi = "com.squareup.moshi:moshi:${DependencieVersions.moshi}"
        const val moshi_codegen =
            "com.squareup.moshi:moshi-kotlin-codegen:${DependencieVersions.moshi}"
    }

    object GitHub {
        //switch keyboard panel
        const val keyboard_panel = "com.github.albfernandez:juniversalchardet:2.4.0"

        const val banner = "io.github.youth5201314:banner:2.2.2"
        const val glide = "com.github.bumptech.glide:glide:4.13.2"

        //ftp
        const val nano_http = "org.nanohttpd:nanohttpd:2.3.1"

        //smb
        const val smbj = "com.hierynomus:smbj:0.10.0"
        const val dcerpc = "com.rapid7.client:dcerpc:0.10.0"
        const val jsoup = "org.jsoup:jsoup:1.11.2"
    }

    object Google {
        const val material = "com.google.android.material:material:1.8.0-alpha01"

        const val exoplayer =
            "com.google.android.exoplayer:exoplayer:${DependencieVersions.exoplayer}"
        const val exoplayer_core =
            "com.google.android.exoplayer:exoplayer-core:${DependencieVersions.exoplayer}"
        const val exoplayer_dash =
            "com.google.android.exoplayer:exoplayer-dash:${DependencieVersions.exoplayer}"
        const val exoplayer_hls =
            "com.google.android.exoplayer:exoplayer-hls:${DependencieVersions.exoplayer}"
        const val exoplayer_smoothstraming =
            "com.google.android.exoplayer:exoplayer-smoothstreaming:${DependencieVersions.exoplayer}"
        const val exoplayer_rtmp =
            "com.google.android.exoplayer:extension-rtmp:${DependencieVersions.exoplayer}"
    }

    object Tencent {
        const val mmkv = "com.tencent:mmkv-static:1.2.14"
        const val bugly = "com.tencent.bugly:crashreport:4.1.9"
    }

    object VLC {
        const val vlc = "org.videolan.android:libvlc-all:3.5.1"
    }
}

如上面的類所示，我們將所有依賴都分類管理，當(dāng)需要使用的時候，直接找對應(yīng)的依賴就行了

2.3 定義APK的打包腳本

在此之前，我們可以先準(zhǔn)備好相關(guān)的輔助工具類，如下所示：
首先是OutputHelper,主要時定義輸出的產(chǎn)物名稱之類的配置，代碼如下所示：

object OutputHelper {
    private val format = SimpleDateFormat("MMddHHmm", Locale.CHINA)

    fun outputFileName(variant: BaseVariantOutput):String{
        val time = format.format(Date())
      return"otterPlayer_v
      ${Versions.versionName}_${variant.name}_$time.apk"  
    }
}

然后是ProjectExtension.kt，這個類主要做的是一些Project的擴(kuò)展，使用kotlin的擴(kuò)展函數(shù)定義，主要用于做一些默認(rèn)的配置，簽名的配置等，由于項目中的很多配置可能都是相同的，所以為了不重復(fù)定義，可以在這里添加上默認(rèn)的這些配置，代碼如下：

fun BaseExtension.setupKotlinOptions() {
    val extensions = (this as ExtensionAware).extensions
    val kotlinOptions = extensions.getByName<KotlinJvmOptions>
    ("kotlinOptions")
    kotlinOptions.apply {
        jvmTarget = JavaVersion.VERSION_1_8.toString()
    }
}

fun BaseExtension.setUpComposeFeature() {
    val extensions = (this as ExtensionAware).extensions
    val kotlinOptions = extensions
    .getByName<KotlinJvmOptions>("kotlinOptions")
}

fun Project.setupDefaultdDependencies() {
    dependencies.apply {
        add(
            "implementation",
            fileTree("include" to listOf("*.jar"), "dir" to "libs")
        )

        add("testImplementation", Dependencies.Junit.junit)
        add("androidTestImplementation", Dependencies.AndroidX.junit_ext)
        add("androidTestImplementation", Dependencies.AndroidX.espresso)
    }
}

fun AppExtension.setUpSignConfigs(project: Project) =
    apply {
        signingConfigs {
            named("debug") {
                SignConfig.debug(project, this)
            }

            create("release") {
                SignConfig.release(project, this)
            }
        }

        buildTypes {
            getByName("debug") {
                signingConfig = signingConfigs.findByName(this.name)
                isMinifyEnabled = false
                proguardFiles(
                    getDefaultProguardFile(
                    "proguard-android-optimize.txt"),"proguard-rules.pro"
                )
            }

            getByName("release") {
                signingConfig = signingConfigs.findByName(this.name)
                isMinifyEnabled = false
                proguardFiles(
                    getDefaultProguardFile(
                    "proguard-android-optimize.txt"),"proguard-rules.pro"
                )
            }

            create("beta") {
                initWith(getByName("release"))
            }
        }
    }

fun AppExtension.setupOutputApk() = apply {
    applicationVariants.all {
        outputs.forEach {
            if (it is ApkVariantOutput) {
                it.outputFileName = OutputHelper.outputFileName(it)
            }
        }
    }
}

最后是簽名配置，我們可以把簽名的信息放到gradle文件夾下，如下：
注意：不要把項目上線時使用的簽名信息放到這里，不安全
然后我們使用一個配置類去讀取這個配置，代碼如下所示：

object SignConfig {

    fun debug(project: Project, config: SigningConfig) {
        val properties = loadProperties(project) ?: return
        config.apply {
            storeFile(project.getAssembleFile(properties["KEY_LOCATION"]
            .toString()))
            storePassword(properties["KEYSTORE_PASS"].toString())
            keyAlias(properties["ALIAS_NAME"].toString())
            keyPassword(properties["ALIAS_PASS"].toString())

            enableV1Signing = true
        }
    }

    fun release(project: Project, config: SigningConfig) {
        val keystoreFile = project.getAssembleFile("dandanplay.jks")
        config.apply {
            storeFile = keystoreFile
            storePassword(System.getenv("KEYSTORE_PASS"))
            keyAlias(System.getenv("ALIAS_NAME"))
            keyPassword(System.getenv("ALIAS_PASS"))
        }
    }

    private fun loadProperties(project: Project): Properties? {
        var propertiesFile = project.getAssembleFile("keystore.properties")
        if (propertiesFile.exists().not()) {
            propertiesFile = project.getAssembleFile("debug.properties")
        }
        if (propertiesFile.exists()) {
            val properties = Properties()
            properties.load(FileInputStream(propertiesFile))
            return properties
        }
        return null
    }

    private fun Project.getAssembleFile(fileName: String): File {
        return File(rootDir, "gradle/assemble/$fileName")
    }
}

定義完輔助的工具類后，我們就可以開始編寫我們的項目構(gòu)建腳本了，我們都知道Android可以有兩種構(gòu)建方式，一種是構(gòu)建應(yīng)用，輸出的是一個APK的文件，可以放到Android手機(jī)上安裝運(yùn)行，另一種是庫文件，包括AAR和JAR。所以我們需要對這兩種構(gòu)建方式分別配置，使用的時候選擇對應(yīng)的配置使用就行了。首先是構(gòu)建APK

構(gòu)建APK的類

un Project.applicationSetup(isComposeUi: Boolean) {
    extensions.getByName<AppExtension>("android").apply {
        compileOptions {
            sourceCompatibility = JavaVersion.VERSION_1_8
            targetCompatibility = JavaVersion.VERSION_1_8
        }

        buildFeatures.apply {
            dataBinding.isEnabled = true
        }

        setupKotlinOptions()
        setUpSignConfigs(this@applicationSetup)
        setupOutputApk()
        if (isComposeUi) {
            buildFeatures.apply {
                compose = true
            }

            composeOptions.apply {
                kotlinCompilerExtensionVersion =
                    Dependencies.getComposeUiVersion() 
            }
        }
    }

    setupDefaultdDependencies()
}

構(gòu)建Module的類

fun Project.moduleSetup() {
    extensions.getByName<LibraryExtension>("android").apply {
        compileSdk = Versions.compileSdkVersion
        defaultConfig {
            minSdk = Versions.minSdkVersion
            targetSdk = Versions.targetSdkVersion
        }

        buildTypes {
            getByName("release") {
                isMinifyEnabled = false
                proguardFiles(
                    getDefaultProguardFile(
                    "proguard-android-optimize.txt"),
                    "proguard-rules.pro"
                )
            }

            getByName("debug") {
                initWith(buildTypes.getByName("debug"))
            }

            create("beta") {
                initWith(buildTypes.getByName("beta"))
            }

            compileOptions {
                sourceCompatibility = JavaVersion.VERSION_1_8
                targetCompatibility = JavaVersion.VERSION_1_8
            }

            buildFeatures {
                dataBinding = true
            }

            setupKotlinOptions()
        }

        setupDefaultdDependencies()
    }
}

代碼很好懂，就不一行行的解釋了，構(gòu)建腳本嘛能用就行了，主要原理就是Kotlin的擴(kuò)展函數(shù)和使用提供的kotlin dsl gradle插件來編寫Android 項目的構(gòu)建腳本

3.使用Gradle Kotlin DSL

當(dāng)我們的構(gòu)建腳本編寫完后就可以使用了，使用起來很簡單，我們新建完Module或者應(yīng)用模塊后，只需要將對應(yīng)的build.gradle文件改造一下就好了，如下所示：

3.1 新建應(yīng)用模塊，產(chǎn)物是APK

如果新建的是一個應(yīng)用模塊，我們需要使用的是applicationSetup這個擴(kuò)展函數(shù)，應(yīng)用模塊下的build.gradle.kts代碼如下所示：

import setup.applicationSetup // 引入我們之前編寫的kotlin dsl構(gòu)建腳本

plugins {
    id("com.android.application") // 表示包產(chǎn)物是應(yīng)用
    kotlin("android")
    kotlin("kapt")
}
applicationSetup(true) // 調(diào)用構(gòu)建APK的擴(kuò)展函數(shù)
// remove warning message because of @Incubating
@Suppress("UnstableApiUsage")
android {
    compileSdk = Versions.compileSdkVersion
    defaultConfig {
        namespace = Versions.applicationId
        applicationId = Versions.applicationId
        minSdk = Versions.minSdkVersion
        targetSdk = Versions.targetSdkVersion
        targetSdk = Versions.targetSdkVersion
        versionCode = Versions.versionCode
        versionName = Versions.versionName
        multiDexEnabled = true
        testInstrumentationRunner
         = "androidx.test.runner.AndroidJUnitRunner"
    }
}

dependencies {
// 引入依賴
    implementation(Dependencies.Junit.junit)
    implementation(Dependencies.AndroidX.lifecycle_runtime_ktx)
    implementation(Dependencies.AndroidX.espresso)

    implementation(Dependencies.AndroidX.core)
    implementation(Dependencies.ComposeUI.compose_ui)
    implementation(Dependencies.ComposeUI.activity_compose)
    implementation(Dependencies.ComposeUI.compose_material)
    implementation(Dependencies.ComposeUI.compose_ui_test_manifest)
    implementation(Dependencies.ComposeUI.compose_ui_tooling_preview)
}

3.2 構(gòu)建庫Module

若新建的是一個module，即產(chǎn)物是AAR或者JAR，我們可以使用moduleSetup() 構(gòu)建，代碼如下：

import setup.moduleSetup

plugins {
    id("com.android.library")
    kotlin("android")
    kotlin("kapt")
    id("kotlin-parcelize")
}

moduleSetup() // 使用構(gòu)建module的方式構(gòu)建模塊

// remove warning message because of @Incubating
@Suppress("UnstableApiUsage")
android {
    namespace = "com.otter.core.player"
    sourceSets {
        getByName("main") {
            jniLibs.srcDir("libs")
        }
    }
}
kapt {
    arguments {
        arg("AROUTER_MODULE_NAME", name)
    }
}

dependencies {

    implementation(Dependencies.VLC.vlc)

    implementation(Dependencies.AndroidX.appcompat)
    implementation(Dependencies.AndroidX.activity_ktx)
    implementation(Dependencies.AndroidX.core)
    implementation(Dependencies.AndroidX.room)
    implementation(Dependencies.AndroidX.junit_ext)
    implementation(Dependencies.AndroidX.androidx_recyclerview)
    implementation(Dependencies.AndroidX.constraintlayout)
    implementation(Dependencies.AndroidX.swiperefreshlayout)
    implementation(Dependencies.AndroidX.androidx_collection_ktx)
}

構(gòu)建庫和構(gòu)建應(yīng)用的步驟差不多，建議讀者可以去多實踐下，體驗一下kotlin gradle dsl帶來的便利。若有高見，歡迎評論區(qū)留言哦文章來源地址http://www.zghlxwxcb.cn/news/detail-648995.html

到了這里，關(guān)于Android使用Gradle kotlin dsl 優(yōu)雅配置構(gòu)建項目的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！