前言

兄dei，Gradle 生命周期有了解过嘛？
emmmmmm….
那么，来说说 Configuration 阶段 Gradle 干了什么吧
emmmmmm….

Gradle 生命周期

Gradle 在编译项目时有着它自己的生命周期，从编译开始编译完毕 Gradle 一共要经历 3 个阶段：

Initialization

初始化阶段，即执行 Gradle 的初始化配置选项，即执行项目中的 settings.gradle 脚本。

Configuration

解析每个 Project 中的 build.gradle 脚本，即解析所有 Project 中的编译选项。解析完成后，Gradle 就生成了一张有向关系图——taskgraph，这面包含了整个 Task 的依赖关系。

Build

该阶段是最后的编译运行阶段，即按照 taskgraph 执行编译。

这三个阶段是宏观把握 Gradle 的核心所在，运行任何 Gradle 指令都会经过这样三个阶段。

默认的输出是在配置阶段，这时候 Gradle 会执行所有 Task 的配置脚本，即使你执行一个指定的 Task，也有到 Build 阶段，才能够开始执行。

Gradle 生命周期的监听

Gradle 耗时 Task 统计

统计 Task 耗时，收集耗时超过100ms 的 Task，排序之后输出到 build 目录下的xxx.txt 文件中。

实现

/**
 * 分析 Task，收集耗时超过 100ms 的task，并将日志输出到 build 文件夹下
 */
fun Gradle.analyzeTask() {

    val clock = Clock()

    val execution = mutableListOf<TaskInfo>()

    addTaskExecutionLifecycle {
        _beforeExecute { task ->
            task.extensions.add("startAt", System.currentTimeMillis())
        }
        _afterExecute { task, _ ->
            // 计算 Task 的执行时间
            val duration = System.currentTimeMillis() - (task.extensions["startAt"] as Long)
            // 收集超过耗时超过 100ms 的 Task
            if (duration >= 100) {
                execution += TaskInfo(task, duration)
            }
        }
    }

    addBuildLifecycle {
        _buildFinished {

            // 没有超过 100ms 的 Task，忽略
            if (execution.isEmpty())
                return@_buildFinished

            // 按照耗时排序
            execution.sortBy { taskInfo ->
                taskInfo.duration
            }

            // 输出内容
            val outputStr = buildString {

                // 构建总耗时
                val buildTimeInSeconds = clock.timesInMs / 1000
                val minutes = buildTimeInSeconds / 60
                val seconds = buildTimeInSeconds % 60

                // 构建字符串模板
                val timeStr = when (minutes) {
                    0L ->
                        "${seconds}s"
                    else ->
                        "${minutes}m ${seconds}s (${buildTimeInSeconds}s)"
                }

                // 文本头
                append("Build finished in ${timeStr}\n")

                // 添加耗时超过 100ms 的 Task
                execution.forEach { taskInfo ->
                    append(
                        String.format(
                            "%7sms %s\n",
                            taskInfo.duration,
                            taskInfo.task.path
                        )
                    )
                }
            }

            // 创建文件，并将内容写入
            val file = File(
                gradle.rootProject.buildDir.absolutePath,
                "build_time_records_${Date().format("yyyy-MM-dd-HH-mm-ss")}.txt"
            )
            file.parentFile.mkdirs()
            file.write(outputStr)
        }
    }
}

监听 TaskExecutionListener 的 beforeExecute 和 afterExecute，计算每一个 Task 的耗时，并且将耗时大于 100ms 的 Task 收集到 execution 中
监听 BuildListener 的 buildFinished， build 结束之后将 execution 排序，并且计算总耗时
最后，将信息写入到 build 目录下的 xxx.txt 文件

PS:这里使用 kotlin 带接收器的扩展函数特性对 addListener 做了简化，让代码看起来更 DSL 一些

参考

Android 群英传神兵利器
- 4.8章，Gradle 思考
Blankj Auc 中统计 Task 耗时的代码