Android Groovy 迁移到 KTS

最新推荐文章于 2024-05-28 17:31:07 发布
最新推荐文章于 2024-05-28 17:31:07 发布
阅读量358 收藏 1
点赞数
分类专栏： Android 文章标签： android kts gradle
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_14876133/article/details/134143513
版权

文章目录

Groovy 迁移到 KTS

概述

Android Studio是使用Gradle来编译，而默认的构建语言是Groovy，但是Gradle实际上是支持Kotlin来编写Gradle构建脚本的，常见的构建脚本是.gradle结尾，而Koltin语法编写的脚本则是.gradle.kts 。

官方文档

主要修改以下配置文件：

  • settings.gradle
  • project/build.gradle
  • app/build.gradle

迁移流程

setting.gradle

以前代码：

rootProject.name = "My Application"
include ':app'

修改为：

rootProject.name = "My Application"
include(":app")

project/build.gradle

以前代码：

buildscript {
    repositories {
        google()
        jcenter()
    }
    dependencies {
        classpath("com.android.tools.build:gradle:${Deploy.gradleVersion}")
        classpath(kotlin("gradle-plugin", Deploy.kotlinVersion))
    }
}

allprojects {
    repositories {
        google()
        jcenter()
    }
}

tasks {
    val clean by registering(Delete::class) {
        delete(buildDir)
    }
}

修改为：

buildscript {
    val kotlinVersion = "1.5.31"
    repositories {
        google()
        mavenCentral()
    }
    dependencies {
        classpath("com.android.tools.build:gradle:4.2.2")
        
//        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion")
        //上面可简写为：
        classpath(kotlin("gradle-plugin", kotlinVersion))
    }
}

allprojects {
    repositories {
        google()
        mavenCentral()
        jcenter()
    }
}

tasks {
    val clean by registering(Delete::class) {
        delete(buildDir)
    }
}

module/build.gradle

在 Gradle 的 Kotlin DSL（KTS）中，register 和 create 都是用于创建和配置对象的方法，但它们的行为有所不同。

  • register：这个方法会创建一个新的对象，但不会立即配置它。配置会在对象被实际需要时（即懒加载）进行。这意味着如果你的构建脚本中没有使用到这个对象，那么它就不会被创建和配置，从而节省了构建时间。
  • create：这个方法会立即创建和配置对象。这意味着无论你的构建脚本中是否使用到这个对象，它都会被创建和配置。 在大多数情况下，你应该优先使用 register，因为它可以提高构建性能。然而，如果你需要立即访问和修改新创建的对象，那么你应该使用 create。

以前代码：

plugins {
    id 'com.android.application'
    id 'kotlin-android'
}

android {
    compileSdkVersion 30
    buildToolsVersion "30.0.0"

    defaultConfig {
        applicationId "com.example.myapplication"
        minSdkVersion 22
        targetSdkVersion 30
        versionCode 1
        versionName "1.0"

        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
    }

    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }
    signingConfigs {
        debug {
            storeFile file('./myjks.jks')
            storePassword "123456"
            keyAlias "app"
            keyPassword "123456"
        }
        release {
            storeFile file('./myjks.jks')
            storePassword "123456"
            keyAlias "app"
            keyPassword "123456"
        }
    }
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }
    kotlinOptions {
        jvmTarget = '1.8'
    }
}

dependencies {
    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
    implementation 'androidx.core:core-ktx:1.3.1'
    implementation 'androidx.appcompat:appcompat:1.2.0'
    implementation 'com.google.android.material:material:1.2.1'
    implementation 'androidx.constraintlayout:constraintlayout:2.0.1'
    testImplementation 'junit:junit:4.+'
    androidTestImplementation 'androidx.test.ext:junit:1.1.2'
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.3.0'
}

修改为：

plugins {
    id("com.android.application")
    
//    id("kotlin-android")
    //上面可简写为：
    kotlin("android")
}

android {
    compileSdkVersion(30)
    buildToolsVersion("30.0.3")

    defaultConfig {
        applicationId = "com.example.myapplication"
        minSdkVersion(22)
        targetSdkVersion(30)
        versionCode = 1
        versionName = "1.0"

        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
    }

    // 配置签名
    signingConfigs {
        getByName("debug") {
            storeFile = file("./myjks.jks")
            storePassword = "123456"
            keyAlias = "app"
            keyPassword = "123456"
        }
        register("release") {
            storeFile = file("./myjks.jks")
            storePassword = "123456"
            keyAlias = "app"
            keyPassword = "123456"
        }
    }

    // 编译类型
    buildTypes {
        getByName("debug") {
            isMinifyEnabled = false
            proguardFiles(
                getDefaultProguardFile("proguard-android-optimize.txt"),
                "proguard-rules.pro"
            )
            signingConfig = signingConfigs.getByName("debug")
        }
        getByName("release") {
            isMinifyEnabled = false
            proguardFiles(
                getDefaultProguardFile("proguard-android-optimize.txt"),
                "proguard-rules.pro"
            )
            signingConfig = signingConfigs.getByName("release")
        }
    }

    // 输出文件名称
    android.applicationVariants.all {
        val buildType = this.buildType.name
        outputs.all {
            if (this is com.android.build.gradle.internal.api.ApkVariantOutputImpl) {
                if (buildType == "debug") {
                    this.outputFileName = "app_V${defaultConfig.versionName}_${buildType}.apk"
                } else if (buildType == "release") {
                    this.outputFileName = "app_V${defaultConfig.versionName}_${buildType}.apk"
                }
            }
        }
    }

    // 部署资源文件
    fun listSubFile(): ArrayList<String> {
        // 新资源目录
        val resFolder = "src/main/res/layouts"
        // 新资源目录下的文件夹
        val files = file(resFolder).listFiles()
        val folders = ArrayList<String>()
        // 遍历路径
        files?.let {
            it.forEach { file ->
                folders.add(file.absolutePath)
            }
        }
        // 资源整合
        folders.add(file(resFolder).parentFile.absolutePath)
        return folders
    }

    // 资源重定向
    sourceSets {
        getByName("main") {
            res.srcDirs(listSubFile())
        }
    }

    // 指定JDK
    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_1_8
        targetCompatibility = JavaVersion.VERSION_1_8
    }

    kotlinOptions {
        jvmTarget = "1.8"
    }

    // 开启ViewBinding
    buildFeatures {
        viewBinding = true
    }
}

dependencies {
    implementation(fileTree(mapOf("dir" to "libs", "include" to listOf("*jar"))))
    implementation("org.jetbrains.kotlin:kotlin-stdlib:1.5.31")
    implementation("androidx.core:core-ktx:1.3.1")
    implementation("androidx.appcompat:appcompat:1.2.0")
    implementation("com.google.android.material:material:1.2.1")
    implementation("androidx.constraintlayout:constraintlayout:2.0.1")
    testImplementation("junit:junit:4.+")
    androidTestImplementation("androidx.test.ext:junit:1.1.2")
    androidTestImplementation("androidx.test.espresso:espresso-core:3.3.0")
    implementation("com.google.code.gson:gson:2.10.1")
}

处理ext扩展函数

在使用 Groovy 语言构建的时候，一般都会抽取一个 config.gradle 来作为全局的变量控制，而ext扩展函数则是必须要使用到的，而在我们的 Gradle Kotlin DSL 中，如果想要使用全局控制，则需要 buildSrc。

buildSrc官网

依次创建如下目录和文件

在这里插入图片描述

build.gradle.kts:

plugins {
    `kotlin-dsl`
}

repositories {
    jcenter()
}

Versions.kt:

object Versions {
    //Android
    const val appCompat = "1.2.0"
    const val constraintlayout = "2.0.1"
    const val junit = "4.+"
    const val testExt = "1.1.2"
    const val espresso = "3.3.0"
    const val lifecycle = "2.5.0"
    const val material = "1.2.1"

    //Kotlin
    const val kotlinVersion = "1.5.31"
    const val coreKtx = "1.3.1"
    const val coroutines = "1.4.3"

    //KTX
    const val activityKtx = "1.2.3"
    const val fragmentKtx = "1.3.6"

    //other
    const val retrofit = "2.9.0"
    const val gson = "2.8.6"
    const val moshi = "1.9.3"
    const val glide = "4.11.0"
}

Libs:

object Libs {
    //Android
    const val appCompat = "androidx.appcompat:appcompat:${Versions.appCompat}"
    const val constraintlayout =
        "androidx.constraintlayout:constraintlayout:${Versions.constraintlayout}"
    const val junit = "junit:junit:${Versions.junit}"
    const val testExt = "androidx.test.ext:junit:${Versions.testExt}"
    const val espresso = "androidx.test.espresso:espresso-core:${Versions.espresso}"
    const val viewmodel = "androidx.lifecycle:lifecycle-viewmodel-ktx:${Versions.lifecycle}"
    const val livedata = "androidx.lifecycle:lifecycle-livedata-ktx:${Versions.lifecycle}"
    const val lifecycle = "androidx.lifecycle:lifecycle-common-java8:${Versions.lifecycle}"
    const val lifecycleRT = "androidx.lifecycle:lifecycle-runtime-ktx:${Versions.lifecycle}"
    const val material = "com.google.android.material:material:${Versions.material}"

    //Kotlin
    const val kotlinStdLib = "org.jetbrains.kotlin:kotlin-stdlib:${Versions.kotlinVersion}"
    const val coreKtx = "androidx.core:core-ktx:${Versions.coreKtx}"
    const val coroutines = "org.jetbrains.kotlinx:kotlinx-coroutines-core:${Versions.coroutines}"
    const val coroutinesTest =
        "org.jetbrains.kotlinx:kotlinx-coroutines-test:${Versions.coroutines}"
    const val coroutinesAndroid =
        "org.jetbrains.kotlinx:kotlinx-coroutines-android:${Versions.coroutines}"

    //KTX
    const val activityKtx = "androidx.activity:activity-ktx:${Versions.activityKtx}"
    const val fragmentKtx = "androidx.fragment:fragment-ktx:${Versions.fragmentKtx}"

    //other
    const val gson = "com.google.code.gson:gson:${Versions.gson}"
    const val moshi = "com.squareup.moshi:moshi:${Versions.moshi}"
    const val moshiCodeGen = "com.squareup.moshi:moshi-kotlin-codegen:${Versions.moshi}"
    const val converterMoshi = "com.squareup.retrofit2:converter-moshi:${Versions.retrofit}"
    const val retrofit = "com.squareup.retrofit2:retrofit:${Versions.retrofit}"
    const val glide = "com.github.bumptech.glide:glide:${Versions.glide}"
    const val glideCompiler = "com.github.bumptech.glide:compiler:${Versions.glide}"
}

ProjectProperties:

object ProjectProperties {
    const val compileSdk = 31
    const val buildTools = "31.0.0"
    const val minSdk = 22
    const val targetSdk = 31

    const val applicationId = "com.example.myapplication"
    const val versionCode = 1
    const val versionName = "1.0.0"

    const val agpVersion = "4.2.2"
}

Deloy:

object Deloy {

    fun getSystemTime(): String {
        val dateFormat = SimpleDateFormat("yyyyMMddHHmmss", Locale.CHINA)
        return dateFormat.format(System.currentTimeMillis())
    }
}

Signing:

object Signing {
    const val StoreFile = "./myjks.jks"
    const val StorePassword = "123456"
    const val KeyAlias = "app"
    const val KeyPassword = "123456"
}
使用

project/build.gradle:

buildscript {
    repositories {
        google()
        mavenCentral()
        jcenter()
    }
    dependencies {
        classpath("com.android.tools.build:gradle:${ProjectProperties.agpVersion}")

        classpath(kotlin("gradle-plugin", Versions.kotlinVersion))
    }
}

allprojects {
    repositories {
        google()
        mavenCentral()
        jcenter()
        maven { url = uri("https://www.jitpack.io") }
        maven { url = uri("https://jitpack.io") }
    }
}

tasks {
    val clean by registering(Delete::class) {
        delete(buildDir)
    }
}

module/build.gradle:

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

android {
    compileSdkVersion(ProjectProperties.compileSdk)
//    buildToolsVersion(ProjectProperties.buildTools)

    defaultConfig {
        applicationId = ProjectProperties.applicationId
        minSdkVersion(ProjectProperties.minSdk)
        targetSdkVersion(ProjectProperties.targetSdk)
        versionCode = ProjectProperties.versionCode
        versionName = ProjectProperties.versionName

        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
    }

    // 配置签名
    signingConfigs {
        getByName("debug") {
            storeFile = file(Signing.StoreFile)
            storePassword = Signing.StorePassword
            keyAlias = Signing.KeyAlias
            keyPassword = Signing.KeyPassword
        }
        register("release") {
            storeFile = file(Signing.StoreFile)
            storePassword = Signing.StorePassword
            keyAlias = Signing.KeyAlias
            keyPassword = Signing.KeyPassword
        }
    }

    // 编译类型
    buildTypes {
        getByName("debug") {
            isMinifyEnabled = false
            proguardFiles(
                getDefaultProguardFile("proguard-android-optimize.txt"),
                "proguard-rules.pro"
            )
            signingConfig = signingConfigs.getByName("debug")
        }
        getByName("release") {
            isMinifyEnabled = false
            proguardFiles(
                getDefaultProguardFile("proguard-android-optimize.txt"),
                "proguard-rules.pro"
            )
            signingConfig = signingConfigs.getByName("release")
        }
    }

    // 输出文件名称
    android.applicationVariants.all {
        val buildType = this.buildType.name
        outputs.all {
            if (this is com.android.build.gradle.internal.api.ApkVariantOutputImpl) {
                if (buildType == "debug") {
                    this.outputFileName = "app_V${defaultConfig.versionName}_${buildType}.apk"
                } else if (buildType == "release") {
                    this.outputFileName =
                        "app_V${defaultConfig.versionName}_${buildType}_${Deloy.getSystemTime()}.apk"
                }
            }
        }
    }

    // 部署资源文件
    fun listSubFile(): ArrayList<String> {
        // 新资源目录
        val resFolder = "src/main/res/layouts"
        // 新资源目录下的文件夹
        val files = file(resFolder).listFiles()
        val folders = ArrayList<String>()
        // 遍历路径
        files?.let {
            it.forEach { file ->
                folders.add(file.absolutePath)
            }
        }
        // 资源整合
        folders.add(file(resFolder).parentFile.absolutePath)
        return folders
    }

    // 资源重定向
    sourceSets {
        getByName("main") {
            res.srcDirs(listSubFile())
        }
    }

    // 指定JDK
    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_1_8
        targetCompatibility = JavaVersion.VERSION_1_8
    }

    kotlinOptions {
        jvmTarget = "1.8"
    }

    // 开启ViewBinding
    buildFeatures {
        viewBinding = true
    }
}

dependencies {
    // Android
    implementation(fileTree(mapOf("dir" to "libs", "include" to listOf("*.jar"))))
    implementation(Libs.appCompat)
    implementation(Libs.constraintlayout)
    implementation(Libs.viewmodel)
    implementation(Libs.livedata)
    implementation(Libs.lifecycle)
    implementation(Libs.lifecycleRT)
    implementation(Libs.material)
    testImplementation(Libs.junit)
    androidTestImplementation(Libs.testExt)
    androidTestImplementation(Libs.espresso)

    // Kotlin
    implementation(Libs.kotlinStdLib)
    implementation(Libs.coreKtx)
    implementation(Libs.coroutines)
    implementation(Libs.coroutinesTest)
    implementation(Libs.coroutinesAndroid)

    //KTX
    implementation(Libs.activityKtx)
    implementation(Libs.fragmentKtx)

    // Network
    implementation(Libs.gson)
    implementation(Libs.retrofit)
    implementation(Libs.moshi)
    implementation(Libs.converterMoshi)
    kapt(Libs.moshiCodeGen)

    // Image
    implementation(Libs.glide)
    kapt(Libs.glideCompiler)
}

源码

xiangxiongfly915
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
build.gradle配置文件的用法
花开花落、云卷云舒的博客
05-19 4903
温故而知新可以为师矣。build文件的各种配置肯定一查一大把，这个是为了方便自己使用查找写的。 1、配置libs".jar"文件： dependencies { ... compile fileTree(include: ['*.jar'], dir: 'libs') } 2、从eclipse工程转到AS工程，里面用到.so文件的jni的配置： androi
Android Gradle 的配置从 Groovy 迁移到 KTS
xiaowang_lj的博客
06-16 3799
虽然与 Groovy 相比，KTS 当前能更好地在 Android Studio 的代码编辑器中集成，但采用 KTS 的构建速度往往比采用 Groovy 慢，因此在迁移到 KTS 时应考虑构建性能。在kts中写法为：implementation(fileTree(mapOf("dir" to "libs", "include" to listOf("*.jar"))))。一个好的策略是首先对所有不明确的语句进行属性分配，然后通过将失败的语句转换为函数调用来修复构建。代码块指定的自定义存储库中提供的插件。
Android Studio Gradle 7.0 kts 使用插件maven-publish
最新发布
weixin_42602900的博客
05-28 185
Android Studio Gradle 7.0 kts 使用插件maven-publish
Android kotlin build.gradle.kts配置
热门推荐
Dream It Possible
02-04 1万+
重新build了下代码，然后找编译后的代码，发现确实没有生成BuildConfig。之前代码相比，也就是AGP的版本升级了下，那猜测是不是跟AGP8.0.0的版本有关，于是在BuildType中手动添加了个buildConfigField，想以此方式强制生成下BuildConfig。我们在新建一个项目然后直接进行Build apk，可以生成一个app_debug.apk的apk文件，那么文件是怎么产生的呢？不同flavor的应用，加载不同的lib，然后某些代码文件，资源也可以使用对应文件夹下的内容替代。
gradle 插件升级和 kts 迁移踩坑指南
chuyouyinghe的专栏
12-19 1999
本文主要分享了 Android gradle 插件升级和 kts 迁移的相关知识和踩坑点。有个前置知识是依赖管理，依赖管理主要使用了，之前写过一篇相关的文章，可以先熟悉下:。谷歌和 gradle 官方都有相关的基础教程，如果你的项目要升级的话最好先详细阅读下和。本文对应的 gradle 版本是 7.5.1，AGP（Android Gradle plugin）版本是 7.3.0，gradle 版本直接看即可，AGP 的最新版本可以参考。为了让大家对迁移有个整体的认识，我画了个思维导图。
将 build 配置从 Groovy 迁移到 Kotlin
qq_21992025的专栏
02-02 373
【代码】将 build 配置从 Groovy 迁移到 Kotlin。
gradle入门（一）从Groovy DSL转化为KTS
luoye的搬砖生活
11-11 2801
从事Android已经很多年了，也尝试学习过gradle。时到如今，回过头来思考的时，思考了下整个学习过程中的痛点，无法直接点击查看源码是真的痛苦，通过implementation 导入源码倒是一种思路，难受总归是难受。 那么有什么方式可以直接点击跳转到源码吗？那就是KTS。我的想法是直接从简单的Demo工程转换为KTS，我们通过KTS去理解调用源码，然后切换成groovy去写脚本。
Gradle指南之从Groovy迁移到Kotlin，androidstudio地图开发
2401_84007015的博客
04-09 978
首先对于 Gradle 这么快就支持 Kotlin DSL，我还是感到很惊喜的，其实，费了不少时间这么折腾了一下，实际上，如果一定要说作用的话，可能确实没有什么作用。但是，我觉得好处还是要说一说的，对于使用 Kotlin 开发的小伙伴来说，首先开发语言和构建语言统一了，之前想写构建脚本，还需要去学习 Groovy。现在直接可以愉快的用 Kotlin 去写 Gradle 构建脚本了。
相比 Groovy 脚本，KTS 性能到底怎么样？
郭霖
03-02 808
/ 今日科技快讯 /近日，有报道称苹果公司在一封致荷兰消费者监管机构的信中称，其已经遵守命令，让旗下苹果应用商店向荷兰约会应用开放第三方支付系统。自1月15日以来，荷兰消费者和市场...
Android - kts文件配置应用签名
孔小乐的博客
09-26 3020
升级最新的AndroidStudio后，gradle配置文件从Groovy 迁移到 KTS，这里把自己配置应用签名遇到的问题及注意事项分享下。Google官方说明地址。
gradle迁移到gradle.kts(复制可用)
小天花藏
06-22 4804
为什么要升级到gradle.kts? 很简单，就是因为gradle.kts带提示功能。本人将针对AndroidStudio的默认构建脚本进行升级。 环境 Android Studio: Android Studio Arctic Fox | 2020.3.1 Patch 2 gradle: 7.0.2 gradle-plugin: 7.0.2 迁移 整个工程一共有3个gradle文件，setting.gradle、Project的build.gradle和Moudle的build.gradle，升级哪个文件
gradle android 配置 build 变体
prime的博客
08-20 1222
> [android 配置 build 变体](https://developer.android.google.cn/studio/build/build-variants) - buildTypes - dependencies - productFlavors - sourceSets
Android gradle 插件升级和 kts 迁移踩坑指南
郭霖
10-10 1987
/ 今日科技快讯 /近期，上海市高新技术企业认定指导小组公告了2022年第一批撤销高新技术企业资格企业名单，包括支付宝（中国）网络科技有限公司等14家企业。对于撤销高新企业资格认证一事，蚂蚁集团相关人士回应表示，支付宝（中国）在上海高新技术企业资格到期后，没有再主动申请。另据高新技术企业认定管理工作网显示，支付宝（杭州）、蚂蚁链、蚂蚁智安安全技术等蚂蚁集团旗下多家主体均被认定为国家高新技术...
gradle命令行区别 build.gradle配置信息1.0 gradle中设置APK输出名称 sourceSets
qq_42015021的博客
05-04 2470
Gradle scripts下面主要是工程的编译配置文件，主要有：1)Bulid.gradle 该文件分为项目级和模块级两种，用于描述App工程的编译规则。2)Proguard-rules.pro 该文件用于描述java代码的混淆规则。3)Gradle.properties，该文件用于配置编译工程的命令行参数，一般无须改动。4)Settings.gradle, 该文件主要配置了需要编译那些模块。初始内容为include ‘:app’，表示只编译app模块。
Gradle 从 Groovy 到 KTS 迁移
川峰的博客
02-07 1516
本文主要记录Groovy版本和kotlin版本的Gradle 相关设置。以便备忘或以后迁移参考。
build.gradle.kts 配置解读
枫飘长安的博客
03-20 2843
build.gradle.kts 配置解读
Android Studio build.gradle.kts
11-15
Android Studio中的build.gradle.kts文件是用Kotlin脚本编写的Gradle构建文件。它与传统的Groovy脚本编写的build.gradle文件相比，具有更好的类型安全性和可读性。以下是一个简单的build.gradle.kts文件的示例： ```kotlin plugins { id("com.android.application") kotlin("android") } android { compileSdkVersion(30) defaultConfig { applicationId = "com.example.myapplication" minSdkVersion(21) targetSdkVersion(30) versionCode = 1 versionName = "1.0" } buildTypes { getByName("release") { isMinifyEnabled = false proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro") } } } dependencies { implementation("androidx.appcompat:appcompat:1.3.1") implementation("com.google.android.material:material:1.4.0") implementation("androidx.constraintlayout:constraintlayout:2.1.0") testImplementation("junit:junit:4.+") androidTestImplementation("androidx.test.ext:junit:1.1.3") androidTestImplementation("androidx.test.espresso:espresso-core:3.4.0") } ``` 在这个示例中，我们定义了一个Android应用程序，并指定了应用程序的ID、最小SDK版本、目标SDK版本、版本代码和版本名称。我们还定义了一个名为“release”的构建类型，并禁用了代码混淆。最后，我们指定了应用程序的依赖项，包括AppCompat、Material Design和ConstraintLayout库。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值