[Android][Compose]Groovy DSL升级Gradle版本

已于 2025-03-31 16:17:25 修改
阅读量486 收藏 8
点赞数 4
CC 4.0 BY-SA版权
文章标签： android
于 2025-03-27 13:20:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_27871511/article/details/146555663

在Android开发领域，Groovy DSL (Domain Specific Language) 主要指的是使用Groovy语言编写的特定领域语言，特别指用于构建配置的Gradle脚本。自从Android Studio 3.0及更高版本以来，Google推荐使用Groovy DSL来编写Android项目的Gradle构建脚本，现在也引入了Kotlin DSL作为替代选项。

本文使用Groovy DSL来进行Gradle版本的升级，并且对其进行compose的环境搭建

更改Gradle分发包的下载URL

distributionUrl属性是这个文件中最关键的一行配置，它的作用是指定Gradle分发包的下载URL。这个URL指向一个特定版本的Gradle二进制包，当你的项目需要使用Gradle进行构建时，如果本地没有对应的Gradle版本，Android Studio或命令行工具会根据distributionUrl指定的地址自动下载该版本的Gradle。

下面使用官方的gradle下载链接，个人推荐还是使用国内镜像源的链接：

distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists
distributionUrl=https\://services.gradle.org/distributions/gradle-7.2-all.zip

更新插件

在Project根目录下build.gradle中更改对应上面下载Gradle的Gradle插件，和添加跟下面要添加compose ui版本对应的kotlin版本，当然要注意Gradle版本7.0后url为http的要添加allowInsecureProtocol = true：

...............

buildscript{
	repositories {
		..........
		maven {
            url "http://xxxxxxxx.xxx"
            allowInsecureProtocol = true
        }
		..........
	}
	dependencies {
		........
		classpath 'com.android.tools.build:gradle:7.1.3' // 使用支持Compose的Android Gradle插件版本
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:1.8.10" // 使用支持Compose的Kotlin版本
		........
	}
}

添加kotlin环境

在Module目录下的build.gradle中添加kotlin插件，并且添加kotlin配置和compose支持。kotlinCompilerExtensionVersion版本跟上面添加的kotlin版本对应。因为要支持compose的环境，所以compileSdk也要升级到33以上：

apply plugin: 'com.android.application'
apply plugin: 'org.jetbrains.kotlin.android'
apply plugin: 'org.jetbrains.kotlin.plugin.parcelize'

android {
	....................
	compileSdk 34
	buildFeatures {
        compose true
    }

    kotlinOptions {
		//这里使用jdk17版本
        jvmTarget = "17"
    }

    composeOptions {
        kotlinCompilerExtensionVersion = "1.4.3"
    }
	....................
}

要注意Gradle版本8.0后需要添加namespace，namespace跟模块名称一致：

android {
    namespace = "com.alibaba.genie.chat.ai"
    compileSdk rootProject.ext.compileSdkVersion
    defaultConfig {
        .....................
    }
	................
}

添加compose依赖

在Module目录下的build.gradle添加compose的依赖，下面进行的是最简单的compose框架依赖添加，在其中的

'androidx.compose:compose-bom:2023.08.00'是Jetpack Compose 使用物料清单：

dependencies {
	//compose
    def composeBom = platform('androidx.compose:compose-bom:2023.08.00')
    implementation composeBom
    androidTestImplementation composeBom
    implementation 'androidx.compose.material3:material3:1.2.1'
}

不过也要注意material3里面已经包含了部分lifecycle的依赖引用，所以会跟例如下面之类的有冲突：

implementation 'androidx.lifecycle:lifecycle-extensions:2.0.0'

这是官方依赖清单：

dependencies {

	def composeBom = platform('androidx.compose:compose-bom:2024.06.00')
	implementation composeBom
	androidTestImplementation composeBom

	// Choose one of the following:
	// Material Design 3
	implementation 'androidx.compose.material3:material3'
	// or Material Design 2
	implementation 'androidx.compose.material:material'
	// or skip Material Design and build directly on top of foundational components
	implementation 'androidx.compose.foundation:foundation'
	// or only import the main APIs for the underlying toolkit systems,
	// such as input and measurement/layout
	implementation 'androidx.compose.ui:ui'

	// Android Studio Preview support
	implementation 'androidx.compose.ui:ui-tooling-preview'
	debugImplementation 'androidx.compose.ui:ui-tooling'

	// UI Tests
	androidTestImplementation 'androidx.compose.ui:ui-test-junit4'
	debugImplementation 'androidx.compose.ui:ui-test-manifest'

	// Optional - Included automatically by material, only add when you need
	// the icons but not the material library (e.g. when using Material3 or a
	// custom design system based on Foundation)
	implementation 'androidx.compose.material:material-icons-core'
	// Optional - Add full set of material icons
	implementation 'androidx.compose.material:material-icons-extended'
	// Optional - Add window size utils
	implementation 'androidx.compose.material3:material3-window-size-class'

	// Optional - Integration with activities
	implementation 'androidx.activity:activity-compose:1.9.0'
	// Optional - Integration with ViewModels
	implementation 'androidx.lifecycle:lifecycle-viewmodel-compose:2.6.1'
	// Optional - Integration with LiveData
	implementation 'androidx.compose.runtime:runtime-livedata'
	// Optional - Integration with RxJava
	implementation 'androidx.compose.runtime:runtime-rxjava2'

}

附件

package com.alibaba.genie.chat.ai.ui.widget
import android.content.Context
import android.nfc.Tag
import android.text.TextUtils
import android.util.AttributeSet
import android.util.Log
import android.widget.FrameLayout
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.livedata.observeAsState
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.geometry.Offset
import androidx.compose.ui.graphics.Brush
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.TileMode
import androidx.compose.ui.platform.ComposeView
import androidx.compose.ui.text.AnnotatedString
import androidx.compose.ui.text.AnnotatedString.Range
import androidx.compose.ui.text.SpanStyle
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.buildAnnotatedString
import androidx.compose.ui.text.withStyle
import androidx.compose.ui.unit.sp
import androidx.lifecycle.MutableLiveData
import com.alibaba.genie.chat.ai.R
import kotlinx.coroutines.delay

class ComposePainterTextView: FrameLayout {
    companion object {
        const val TAG = "AiChatScreen"
    }
    private val text = MutableLiveData<String>("")

    private val displayText = MutableLiveData<AnnotatedString>(AnnotatedString(""))

    private val textList = mutableListOf<String>()

    private var mHighlightStr = MutableLiveData<String>("")

    private var isRealEnd = MutableLiveData<Boolean>(false)

    private var mRange: Range<SpanStyle>? = null

    private var textStyle: TextStyle = TextStyle(
        fontSize = 30.sp
    )

    private var needPrinting: Boolean = true

    private var needPausePrinting = MutableLiveData<Boolean>(false)

    private val mIsPainting = MutableLiveData<Boolean>(false)

    private val brush: Brush = Brush.linearGradient(
        listOf(
            Color.Blue,
            Color.Red,
            Color.Green
        ),
        start = Offset(0f,0f),
        end = Offset(1050f,0f),
        TileMode.Clamp
    )

    private var listener: TextAnimationListener? = null

    constructor(context: Context) : this(context, null)

    constructor(context: Context, attrs: AttributeSet?) : this(context, attrs, 0)

    constructor(context: Context, attrs: AttributeSet?, defStyleAttr: Int) : super(context, attrs, defStyleAttr) {
        val typedArray = context.obtainStyledAttributes(attrs, R.styleable.PrinterTextView)
        val textColor = typedArray.getColor(R.styleable.PrinterTextView_textColor, resources.getColor(R.color.normalTextColor))
        val textSize = typedArray.getDimension(R.styleable.PrinterTextView_textSize, 60f)
        Log.i(TAG, "textColor: $textColor, textSize=$textSize")
        textStyle = TextStyle(
            color = Color(textColor),
            fontSize = (textSize / 3).sp
        )
        typedArray.recycle()
        initView(context)
    }

    private fun initView(context: Context) {
        addView(
            ComposeView(context).apply {
                setContent {
                    val string = text.observeAsState()
                    val highlightStr = mHighlightStr.observeAsState()
                    val needPausePrinting by this@ComposePainterTextView.needPausePrinting.observeAsState()
                    TextBrushScreen(string.value ?:"", highlightStr.value ?:"", needPausePrinting ?:false)
                }
            }
        )
    }

    fun setHighlightStr(highlightStr: String): Boolean {
        if (mHighlightStr.value == highlightStr) {
            Log.w(TAG, "setHighlightStr: return $highlightStr")
            return false
        }
        mHighlightStr.value = highlightStr
        updateHighlightSpan()
        return true
    }

    fun setTextAnimationListener(listener: TextAnimationListener?) {
        this.listener = listener
    }

    fun setNeedPrinting(needPrinting: Boolean) {
        this.needPrinting = needPrinting
    }

    fun setPausePrinting(needPausePrinting: Boolean) {
        Log.w(TAG, "setPausePrinting:${needPausePrinting}, text=${text.value}", )
        this.needPausePrinting.value = needPausePrinting
    }

    fun setText(text: String, tag: String = "") {
        Log.w(TAG, "setText: tag=$tag, text=${text}", )
        this.textList.clear()
        this.textList.add(text)
        this.text.value = text
    }

    fun setText(textId: Int) {
        try {
            val text = resources.getText(textId)
            Log.w(TAG, "setText: text=${text.toString()}", )
            this.textList.clear()
            this.textList.add(text.toString())
            this.text.value = text.toString()
            this.displayText.value = AnnotatedString(text.toString())
        } catch (e: Exception) {
            println()
            return
        }
    }

    fun setTextStyle(textStyle: TextStyle) {
        this.textStyle = textStyle
    }

    fun setIsEnd(value : Boolean) {
        Log.w(TAG, "setIsEnd: $value", )
        isRealEnd.value = value
    }

    fun isPrintTaskEmpty(): Boolean {
        return mIsPainting.value != true
    }

    fun clearText(): ComposePainterTextView {
        textList.clear()
        text.value = ""
        displayText.value = AnnotatedString("")
        mHighlightStr.value = ""
        return this
    }

    private fun updateHighlightSpan() {
        val highlightStr = mHighlightStr.value ?:return
        var start = text.value?.indexOf(highlightStr) ?: return
        Log.w(TAG, "updateHighlightSpan: start=${start},TextUtils.isEmpty(text.value)=${TextUtils.isEmpty(text.value)}", )
        if (start < 0) {
            if (!TextUtils.isEmpty(text.value) && mHighlightStr.value?.startsWith(text.value!!) == true) {
                start = 0
            } else {
                appendTaskToQueue(highlightStr)
                updateHighlightSpan()
                return
            }
        }
        Log.w(TAG, "setHighlightStr: highlightStr $highlightStr, start=${start}, end=${start + highlightStr.length},highlightStr.length=${highlightStr.length}")
        mRange = Range(
            SpanStyle(brush = brush),
            start = start,
            end = start + highlightStr.length
        )
    }

    fun appendTaskToQueue(text: String) {
        Log.w(TAG, "appendTaskToQueue: text=${text}", )
        if (textList.contains(text)) {
            return
        } else {
            textList.add(text)
            this.text.value += text
            needPrinting = true
            needPausePrinting.value = false
        }
    }

    @Composable
    fun TextBrushScreen(text: String, highlightStr: String, needPausePrinting: Boolean) {
        Box(modifier = Modifier.fillMaxSize()) {
//            var printedText: AnnotatedString by remember { mutableStateOf(
//                AnnotatedString("")
//            ) }
            val printedText by displayText.observeAsState(AnnotatedString(""))
            var cursorText : AnnotatedString by remember { mutableStateOf(
                AnnotatedString("")
            ) }

            val isPainting by mIsPainting.observeAsState(initial = false)
            LaunchedEffect(key1 = UInt) {
                while (true) {
                    delay(200)
                    val needUpdateHighlight = if (mRange == null) {
                        false
                    } else if (printedText.text.length < mRange!!.start || printedText.text.length > mRange!!.end) {
                        false
                    } else {
                        true
                    }

                    val string = if ((isPainting || (isRealEnd.value != true && needPrinting)) && cursorText.text == "  ") {
                        "__"
                    } else {
                        "  "
                    }
                    cursorText = buildAnnotatedString {
                        if (needUpdateHighlight) {
                            withStyle(
                                SpanStyle(brush)
                            ) {
                                append(string)
                            }
                        } else {
                            append(string)
                        }
                    }
                }
            }
            LaunchedEffect(key1 = text, highlightStr, needPausePrinting) {
                if (TextUtils.isEmpty(text)) {
                    displayText.value = AnnotatedString("")
                    return@LaunchedEffect
                }
                mIsPainting.value = true
                text.forEachIndexed { index, char ->
                    val needUpdateText = printedText.length < index + 1 && !needPausePrinting
                    val needUpdateHighlight = (printedText.spanStyles.isNotEmpty() && !printedText.spanStyles.contains(mRange)) || (printedText.spanStyles.isEmpty() && mRange !=null )
                    val string = if (needUpdateText) {
                        printedText.text + char
                    } else {
                        printedText.text
                    }
                    if (needUpdateHighlight || needUpdateText) {
                        displayText.value = buildAnnotatedString{
                            if (mRange == null || mRange!!.start > index){
//                                    Log.w(TAG, "mRange == null || mRange!!.start > index, index=$index, mRange!!.start=${mRange?.start}")
                                append(string)
                            }else if (mRange!!.start <= index) {
                                val start = mRange!!.start
                                val end = if (mRange!!.end > string.length) {
                                    string.length
                                } else {
                                    mRange!!.end
                                }
//                                Log.w(TAG, "TextBrushScreen: index=${index}, string.length=${string.length}, start=${start}, mRange?.end=${mRange?.end}, end=${end}, needPausePrinting=${needPausePrinting}")

                                if ( start <= string.length && end <= string.length) {
                                    if (start > 0) {
                                        append(string.substring(0, start))
                                    }

                                    withStyle(
                                        SpanStyle(brush)
                                    ){
                                        append(string.substring(start, end))
                                    }

                                    append(string.substring(end, string.length))
                                }
                            } else {
//                                Log.w(TAG, "TextBrushScreen: index=${index}, mRange?.start=${mRange?.start}, mRange?.end=${mRange?.end}")
                            }
                        }
                        if (needUpdateText && needPrinting) {
                            delay(100)
                        }

                    }
                }
                mIsPainting.value = false
                listener?.animationFinish()
            }
//            Log.w(TAG, "TextBrushScreen: text=${text}", )
            Text(
                modifier = Modifier
                    .fillMaxWidth()
                    .align(Alignment.Center),
                text = printedText + cursorText,
                style = textStyle
            )
        }
    }

    interface TextAnimationListener {
        fun animationFinish()
    }
}

给旧Activity添加生命周期

添加依赖

//compose
    def composeBom = platform('androidx.compose:compose-bom:2023.08.00')
    implementation composeBom
    androidTestImplementation composeBom
    implementation 'androidx.compose.material3:material3:1.2.1'
    implementation "androidx.lifecycle:lifecycle-viewmodel-compose:$lifecycle_version"

def lifecycle_version = "2.7.0"
    implementation "androidx.lifecycle:lifecycle-runtime:$lifecycle_version"
    implementation "androidx.lifecycle:lifecycle-viewmodel:$lifecycle_version"
    implementation "androidx.lifecycle:lifecycle-livedata:$lifecycle_version"

代码：

package com.cocos.game.base

import android.app.Activity
import android.os.Bundle
import android.view.View
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleOwner
import androidx.lifecycle.LifecycleRegistry
import androidx.lifecycle.ViewModelStore
import androidx.lifecycle.ViewModelStoreOwner
import androidx.lifecycle.setViewTreeLifecycleOwner
import androidx.lifecycle.setViewTreeViewModelStoreOwner
import androidx.savedstate.SavedStateRegistry
import androidx.savedstate.SavedStateRegistryController
import androidx.savedstate.SavedStateRegistryOwner
import androidx.savedstate.setViewTreeSavedStateRegistryOwner
import com.cocos.lib.CocosActivity

class BaseCocosActivity: Activity(), LifecycleOwner, ViewModelStoreOwner, SavedStateRegistryOwner{
    private val lifecycleRegistry: LifecycleRegistry = LifecycleRegistry(this)
    private val savedStateRegistryController = SavedStateRegistryController.create(this)
    private val store = ViewModelStore()

    override val lifecycle: Lifecycle
        get() = lifecycleRegistry
    override val savedStateRegistry: SavedStateRegistry
        get() = savedStateRegistryController.savedStateRegistry
    override val viewModelStore: ViewModelStore
        get() = store


    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        savedStateRegistryController.performRestore(null)
        lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE)
    }

    override fun onStart() {
        super.onStart()
        lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START)
    }

    override fun onResume() {
        super.onResume()
        lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME)
    }

    override fun onPause() {
        super.onPause()
        lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    }

    override fun onStop() {
        super.onStop()
        lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP)
    }

    override fun onDestroy() {
        super.onDestroy()
        lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY)
        store.clear()
    }

    /**
     * Compose uses the Window's decor view to locate the
     * Lifecycle/ViewModel/SavedStateRegistry owners.
     * Therefore, we need to set this class as the "owner" for the decor view.
     */
    fun attachToDecorView(decorView: View?) {
        decorView?.let {
            it.setViewTreeViewModelStoreOwner(this)
            it.setViewTreeLifecycleOwner(this)
            it.setViewTreeSavedStateRegistryOwner(this)
        } ?: return
    }
}

完毕

qq_27871511
关注
移动开发：Gradle与Android Studio的完美结合
移动开发前沿的博客
05-28 1093
本文聚焦Android开发中最核心的"构建环节"，重点讲解Gradle（构建工具）与Android Studio（开发IDE）如何深度配合，解决从代码编译到APK生成的全流程问题。内容覆盖基础概念、协作原理、实战技巧及性能优化，帮助开发者理解"看不见的构建过程"，并掌握高效开发的关键工具。本文将按照"故事引入→核心概念→协作原理→实战操作→优化技巧→未来趋势"的逻辑展开，用生活化的比喻降低理解门槛，结合代码示例和流程图直观展示技术细节。Gradle。
Android Studio：创建一个简单的Jetpack Compose项目
fjnu_se的博客
01-13 1751
Jetpack Compose是用于构建原生Android UI的现代工具包。它采用了声明式编程模型，这意味着你只需描述你的UI应该是什么样子，而Compose会处理其余的事情。这使得编写简洁、易读且易于维护的代码成为可能。在开始之前，请确保你的Android Studio版本至少为4.0以上，因为Jetpack Compose需要这些版本的支持，并且更新Gradle插件，有时，旧版本的AGP（Android Gradle Plugin）可能不支持最新的Jetpack Compose功能。
【Android】Android Studio kotlin DSL导包指南
天枢破军的博客
05-29 1142
新版本的修改了脚本的写法，从原本的Groovy DSL改成了kotlin DSL，第一次接触有点不知所措。自己摸索了一下，写个记录给后来人指路。
Kotlin DSL 实战：像 Compose 一样写代码
xiaxia20220117的博客
02-28 624
1. 前言 Kotlin 是一门对 DSL 友好的语言，它的许多语法特性有助于 DSL 的打造，提升特定场景下代码的可读性和安全性。本文将带你了解 Kotlin DSL 的一般实现步骤，以及如何通过 @DslMarker ， Context Receivers 等特性提升 DSL 的易用性。 2. 什么是 DSL？ DSL 全称是 Domain Specific Language，即领域特定语言。顾名思义 DSL 是用来专门解决某一特定问题的语言，比如我们常见的 SQL 或者正则表达式等，DSL 没有通用编
Groovy 闭包与DSL(特定领域语言)
最新发布
dj1955的博客
07-09 142
它类似于 Java 的 Lambda 表达式，是一个可以作为参数传递的代码块（参数是代码块），可以选择在合适的位置延后执行Jenkins Pipeline 使用了来模拟出类似 JSON 配置文件的结构。
Kotlin | DSL
qq_37196748的博客
07-24 2720
这里写目录标题KotlinDSL篇（一）前言一、What's the DSL？二、使用步骤1.引入库2.读入数据总结二、使用步骤1.引入库2.读入数据总结三级目录 Kotlin DSL篇（一） 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录KotlinDSL篇（一）前言一、What's the DSL？二、使用步骤1.引入库2.读入数据总结二、使用步骤
像 Compose 那样写代码 ：Kotlin DSL 原理与实战
移动端开发干货分享
02-28 5294
1. 前言 Kotlin 是一门对 DSL 友好的语言，它的许多语法特性有助于 DSL 的打造，提升特定场景下代码的可读性和安全性。本文将带你了解 Kotlin DSL 的一般实现步骤，以及如何通过 @DslMarker ， Context Receivers 等特性提升 DSL 的易用性。 2. 什么是 DSL？ DSL 全称是 Domain Specific Language，即领域特定语言。顾名思义 DSL 是用来专门解决某一特定问题的语言，比如我们常见的 SQL 或者正则表达式等，DSL 没有
gradle 6.7.1 升级到7.5
a8484936的博客
06-29 4300
gradle升级到7.4.2
Groovy Bean定义DSL
2301_77822280的博客
05-20 628
现任何复杂的语法配置，但是对于配置，我们需要那么复杂吗？坏，只有适用不适用；脚本，所以可以做非常复杂的配置，如果以上问题能够解决，其也是一个不。到此基本的使用就结束了，还算是比较简洁，但是我们已经注意到了，在纯。就介绍完了，其没有什么特别之处，只是换了种写法而已，我认为目前试。、编辑器的代码补全需要跟进，否则没有代码补全，写这个很痛苦；内部支持完善，且编辑器支持也非常好的话，也是不。中的话使用这种配置感觉不会有什么问题，但是在纯。我的感觉是这个功能其目的是去推广它的。的，可以自己推到其他相关的配置；
android studio Groovy DSL怎么自动切换自己在layout设计的两个界面
03-26
好的，我现在需要解决用户的问题，关于如何在Android Studio中使用Groovy DSL实现布局设计时两个界面之间的自动切换。首先，我需要理解用户的具体需求。用户提到的是使用Groovy DSL，也就是在build.gradle文件中配置...
gradle-dcompose-plugin：类似于Docker Compose for Gradle的插件
02-04
这个插件是用 Groovy 编写的，因此它与 Gradle 的 Groovy DSL 集成得非常紧密。 ### 2. 安装与配置 要在 Gradle 项目中使用 `gradle-dcompose-plugin`，首先需要在 `build.gradle` 文件中添加插件依赖。通常，你会...
Groovy DSL –一个简单的例子
03-29 777
领域专用语言（DSL）已成为Groovy习语的重要组成部分。 DSL用于本地Groovy构建器，Grails和GORM，以及测试框架。 对于开发人员而言，DSL是易用且易于理解的，与传统编程相比，这使实现更加流畅。 但是如何实现DSL？ 它在后台如何工作？ 本文将演示一个简单的DSL，它可以使开发人员开始了解基本概念。 什么是DSL DSL旨在解决特定类型的问题。 它们是很短的表达方...
使用groovy实现一个简单的DSL
tianhaolin1991的博客
06-27 1699
目标:积分奖励系统 原有的消费系统:BroadbandPlus BroadbandPlus 假设我们有一个服务:BroadbandPlus 在BroadbandPlus上用户有三种不同的订阅级别:BASIC/PLUS/PREMIUM(额外付费),根据订阅级别不同,每个月给用户发放不同的积分(access points).当然啦.不同的订阅级别每个月支付的费用是不同的 Subsciption level cost per month Access points Basic $9.99 1
Android Gradle构建脚本基础（三）
KyungLip的博客
05-07 2501
1. settings.gradle文件 位于项目根目录下，用于项目的配置，常见的是配置子工程。可以类比认识，根工程对应AndroidStudio项目中的Project,子工程对应Module。 一个子工程只有在setting.gradle中配置了，才能够被识别，构建的时候才会被包含进去。 rootProject.name = "GradleGuide" include ':app' include ':demo' project(":demo").projectDir=new File(rootDir
android studio项目gradle从3.0.0升级到7.4.2的详细步骤
weixin_48336327的博客
05-09 2640
最近因项目需要必须要将gradle升级到7.4.2，升级过程一波三折，问题太多，因此将详细过程记录下来，为以后升级做参考。我的android studio目前的版本是Arctic Fox | 2020.3.1。
Android studio gradle7.1.3 如何发布jitpack开源项目（以gitee项目为例）
cmmboy1990的博客
04-24 3074
android gradle7.1.3 发布gitee开源项目到jitpack
AS 更新gradle
cunjicsdn的专栏
07-24 2060
两种方式 一、自动更新 1、在你所在项目文件夹下：你项目根目录gradle\wrapper\gradle-wrapper.properties 修改gradle-wrapper.properties最后一行的地址 例如修改gradle-5.0-all.zip为gradle-5.5-all.zip 然后Sync Now 二、手动更新http:/...
关于安卓compose在gradle8.0上，版本依赖的问题
motosheep的博客
01-26 1176
安卓配置compose依赖
2023年Android Gradle、Gradle插件以及Kotlin版本升级记录
热门推荐
No errors,no gains!
09-17 1万+
2023年Android Gradle、Gradle插件以及Kotlin版本升级记录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值