gradle学习2

gradle 学习

gradle生命周期

生命周期

初始化阶段=》配置阶段=》执行阶段

生命周期回调

![在这里插入图片描述](https://img-blog.csdnimg.cn/2

获取project

获取所有project

this.projects()
def projects() {

    this.getAllprojects().eachWithIndex { project, index ->
        if (index ==0 ) {
            println "root = ${project.name}"
        } else {
            println "sub ${project.name}"
        }
    }
}

获取子project

this.subProject()
def subProject() {
    this.getSubprojects().eachWithIndex { Project entry, int i ->
        println "sub project ${entry.name}"
    }
}

得到父的project

方式一，该方式不能在父project调用会报错

this.getParentProject()

def getParentProject() {
    def name = this.getParent().name
    println "parent = ${name}"
}

方式二，该方式可以在父project调用

this.rootProject()

def rootProject() {
    def name = this.rootProject.name
    println "root name ${name}"
}

对某一project进行设置

添加plugin、dependencies

project('app') { Project project ->

    apply { ObjectConfigurationAction objectConfigurationAction ->
//        objectConfigurationAction.plugin('com.android.library')
    }


    project.afterEvaluate {
        dependencies {  DependencyHandler dependencyHandler ->
            dependencyHandler.add('implementation', 'com.google.code.gson:gson:2.6.2')
        }
    }
}

    apply { ObjectConfigurationAction objectConfigurationAction ->
        // objectConfigurationAction.plugin('com.android.library')
    }

apply是追加插件，如果已经存在com.android.application，如继续追加com.android.library插件会报错

配置当前工程和所有子工程

allprojects {
    group 'com.answer'
    version '1.0.0-release'
}
println "aaa" + project("app").group

配置子project，不包括当前project

subprojects { Project project ->
    if(project.getPlugins().hasPlugin('com.android.library')) {
        apply from: '../publishToMaven.gradle'
    }
}

判断子project是不是library，如果是，就增加发不到maven仓库功能、

扩展

在根工程使用ext

ext {
    compileSdkVersion = 29
    libAndroidx = 'androidx.appcompat:appcompat:1.2.0'
}

子工程使用根工程的扩展函数

方式一

android {
    compileSdkVersion this.rootProject.compileSdkVersion
    buildToolsVersion "29.0.2"

方式二

因为是继承关系，所以可以省略掉rootProject

android {
    compileSdkVersion this.compileSdkVersion
    buildToolsVersion "29.0.2"

导入文件使用扩展函数

创建一个common.gradle文件

在跟工程进行引用

在子工程进行使用

使用属性

文件操作

文件路径

查找文件

相对于当前的project工程开始查找

println buildContent("common.gradle")
def buildContent(String path) {
    try {
        def file = file(path)
        return file.text
    } catch (GradleException e) {
        println 'file not found.'
    }
    return null
}

复制文件

复制单个文件

copy {
    from file('hahaha.jks')
    into getRootProject().getBuildDir().absolutePath
}

复制目录

copy {
    from file('build/outputs/apk/')
    into getRootProject().getBuildDir().path + '/apk'
}

遍历文件树

fileTree('build/outputs/apk/') { FileTree fileTree ->
    fileTree.visit { FileTreeElement element ->
        println 'the file name is ' + element.file.name
    }
}

依赖

buildscript { ScriptHandler scriptHandler ->
	// 配置工程的仓库地址
    scriptHandler.repositories { RepositoryHandler repositoryHandler ->
        repositoryHandler.jcenter()
        repositoryHandler.mavenCentral()
        repositoryHandler.mavenLocal()

        repositoryHandler.google()
        repositoryHandler.maven { MavenArtifactRepository mavenArtifactRepository ->
            mavenArtifactRepository.setName('')
            mavenArtifactRepository.setUrl('')
            mavenArtifactRepository.credentials(new Action<PasswordCredentials>() {
                @Override
                void execute(PasswordCredentials passwordCredentials) {
                    passwordCredentials.setUsername()
                    passwordCredentials.password()
                }
            })
        }
    }
	// 配置工程的"插件"依赖地址
    dependencies {
        classpath 'com.android.tools.build:gradle:3.6.3'


        // NOTE: Do not place your application dependencies here; they belong
        // in the individual module build.gradle files
    }
}

排除依赖

exclude

transitive

执行终端命令

task(pwdCommand {
    doLast {
        def command = "pwd"
        exec {
            try {
                executable 'bash'
                args '-c', command
            }catch(GradleException e) {
                println 'the command is executed failed'
            }
        }
    }
})

task

创建task

方式一

task(helloTask {
    println 'hello task'
})

方式二

this.tasks.create(name: 'helloTask2') {
    println 'hello task222'
}

对task进行配置

方式一

task(helloTask(group: 'yaoyan', description: 'this is yaoyan') {
    println 'hello task'
})

方式二

this.tasks.create(name: 'helloTask2') {
    setGroup('xixi')
    setDescription('this is xixi')
    println 'hello task222'
}

在gradle执行阶段处理逻辑

task(helloTask(group: 'yaoyan', description: 'this is yaoyan') {
    println 'hello task'
    doFirst {
        println 'the task group is: ' + group
    }
    doLast {

    }
})
helloTask.doFirst {
    println 'the task description is: ' + description
}

外面的doFirst先执行

task依赖关系

单个依赖

task taskX {
    doLast {
        println 'taskX'
    }
}

task taskY {
    doLast {
        println 'taskY'
    }
}

task taskZ(dependsOn: taskX) {
    doLast {
        println 'taskZ'
    }
}

多个依赖

task taskX {
    doLast {
        println 'taskX'
    }
}

task taskY {
    doLast {
        println 'taskY'
    }
}

task taskZ(dependsOn: [taskX, taskY]) {
    doLast {
        println 'taskZ'
    }
}

动态添加task

task lib1 {
    doLast {
        println 'lib1'
    }

}

task lib2 {
    doLast {
        println 'lib2'
    }
}

task noLib {
    doLast {
        println 'noLib'
    }

}

task taskX {
    dependsOn this.tasks.findAll { task ->
        return task.name.startsWith('lib')
    }
    doLast {
        println 'taskX'
    }
}

gradle 输入输出

}

task writeTask {
    inputs.property('versionCode', this.versionCode)
    inputs.property('versionName', this.versionName)
    inputs.property('versionInfo', this.versionInfo)
    outputs.file this.destFile
    doLast {
        println '开始写了'
        //将输入的内容写入到输出文件中去
        def data = inputs.getProperties()
        File file = outputs.getFiles().getSingleFile()
        def versionMsg = new VersionMsg(data)
        //将实体对象写入到xml文件中
        def sw = new StringWriter()
        def xmlBuilder = new MarkupBuilder(sw)
        if (file.text != null && file.text.size() <= 0) {
            //没有内容
            xmlBuilder.releases {
                release {
                    versionCode(versionMsg.versionCode)
                    versionName(versionMsg.versionName)
                    versionInfo(versionMsg.versionInfo)
                }
            }
            //直接写入
            file.withWriter { writer -> writer.append(sw.toString())
            }
        } else {
            //已有其它版本内容
            xmlBuilder.release {
                versionCode(versionMsg.versionCode)
                versionName(versionMsg.versionName)
                versionInfo(versionMsg.versionInfo)
            }
            //插入到最后一行前面
            def lines = file.readLines()
            def lengths = lines.size() - 1
            file.withWriter { writer ->
                lines.eachWithIndex { line, index ->
                    if (index != lengths) {
                        writer.append(line + '\r\n')
                    } else if (index == lengths) {
                        writer.append('\r\r\n' + sw.toString() + '\r\n')
                        writer.append(lines.get(lengths))
                    }
                }
            }
        }
    }
}

class VersionMsg {
    String versionCode
    String versionName
    String versionInfo
}

task readTask {
    //指定输入文件为上一个task的输出
    inputs.file this.destFile
    doLast {
        //读取输入文件的内容并显示
        def file = inputs.files.singleFile
        println file.text
    }
}


task taskZ {
    dependsOn writeTask, readTask
    doLast {
        println '输入输出任务结束'
    }
}

task指定顺序

task taskA {
    doLast {
        println 'taskA'
    }
}

task taskB {
    mustRunAfter taskA
    doLast {
        println 'taskB'
    }
}

task taskC {
    mustRunAfter taskB
    doLast {
        println 'taskC'
    }
}

sourceSets

android {
    compileSdkVersion 29
    buildToolsVersion "29.0.2"

    defaultConfig {
        applicationId "com.answer.myapplication"
        minSdkVersion 17
        targetSdkVersion 29
        versionCode 1
        versionName "1.0"

        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
    }

    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }
    sourceSets {
        main {
            jniLibs.srcDirs = ['libs']
        }
    }

    sourceSets {
        main {
            res.srcDirs = ['src/main/res', 'src/main/res-ad']
        }
    }
}

增加了一个res目录

自定义插件

工程目录

自定义插件

/**
 * 自定义Plugin
 */
class GradleStudyPlugin implements Plugin<Project> {

    /**
     * 唯一需要实现的就是这个方法，参数就是引入了当前插件的Project对象
     * @param project
     */
    @Override
    void apply(Project project) {
        project.extensions.create('yaoyanInfo', ReleaseInfoExtension)
        //创建Task
        project.tasks.create('yaoyanReleaseInfoTask',
                ReleaseInfoTask)
    }
}

自定义属性

class ReleaseInfoExtension {
    String versionCode
    String versionName
    String versionInfo
    String fileName

    ReleaseInfoExtension() {

    }

    @Override
    String toString() {
        """| versionCode = ${versionCode}
           | versionName = ${versionName}
           | versionInfo = ${versionInfo}
           | fileName = ${fileName}
        """.stripMargin()
    }
}

自定义task

import groovy.xml.MarkupBuilder
import org.gradle.api.DefaultTask
import org.gradle.api.tasks.TaskAction

class ReleaseInfoTask extends DefaultTask {
    ReleaseInfoTask() {
        group = 'yaoyan'
        description = 'update the release info'
    }

    /**
     * 执行于gradle执行阶段的代码,在doFirst之后，doLast之前执行
     */
    @TaskAction
    void doAction() {
        updateInfo()
    }

    //真正的将Extension类中的信息呢，写入指定文件中
    private void updateInfo() {
        //获取将要写入的信息
        String versionCodeMsg = project.extensions.
                yaoyanInfo.versionCode
        String versionNameMsg = project.extensions.
                yaoyanInfo.versionName
        String versionInfoMsg = project.extensions.
                yaoyanInfo.versionInfo
        String fileName = project.extensions.
                yaoyanInfo.fileName
        def file = project.file(fileName)
        if (!file.exists()) {
            file.createNewFile()
        }
        //将实体对象写入到xml文件中
        def sw = new StringWriter()
        def xmlBuilder = new MarkupBuilder(sw)
        if (file.text != null && file.text.size() <= 0) {
            //没有内容
            xmlBuilder.releases {
                release {
                    versionCode(versionCodeMsg)
                    versionName(versionNameMsg)
                    versionInfo(versionInfoMsg)
                }
            }
            //直接写入
            file.withWriter { writer -> writer.append(sw.toString())
            }
        } else {
            //已有其它版本内容
            xmlBuilder.release {
                versionCode(versionCodeMsg)
                versionName(versionNameMsg)
                versionInfo(versionInfoMsg)
            }
            //插入到最后一行前面
            def lines = file.readLines()
            def lengths = lines.size() - 1
            file.withWriter { writer ->
                lines.eachWithIndex { line, index ->
                    if (index != lengths) {
                        writer.append(line + '\r\n')
                    } else if (index == lengths) {
                        writer.append('\r\r\n' + sw.toString() + '\r\n')
                        writer.append(lines.get(lengths))
                    }
                }
            }
        }

    }
}

配置文件

main/resources/META-INF/gradle-plugins/com.yaoyan.gradle.study.properties

implementation-class=com.yaoyan.gradle.study.GradleStudyPlugin

使用

apply plugin: 'com.yaoyan.gradle.study'

yaoyanInfo {
     versionCode = '1.0.0'
     versionName = '100'
     versionInfo = 'xixi'
     fileName = 'releases.xml'
}