Android创建本地plugin工程

最新推荐文章于 2025-12-18 21:03:42 发布

原创最新推荐文章于 2025-12-18 21:03:42 发布 · 438 阅读

CC 4.0 BY-SA版权

文章标签：

MyApplication/
├── settings.gradle.kts                 <-- 主工程 settings
├── build.gradle.kts                    <-- 主工程 build
├── gradle/
│   └── libs.versions.toml             <-- 主工程 catalog（含 pluginA/pluginB alias）
└── plugins/                            <-- 本地插件根工程（复合构建）
    ├── settings.gradle.kts
    ├── gradle/
    │   └── libs.versions.toml          <-- 插件工程自己的 catalog（最小依赖）
    ├── pluginA/
    │   ├── build.gradle.kts
    │   └── src/main/kotlin/com/example/PluginA.kt
    └── pluginB/
        ├── build.gradle.kts
        └── src/main/kotlin/com/example/PluginB.kt

1. 主工程目录准备

在你的 Android 工程根目录 MyApplication/ 下，应该已经有：

MyApplication/
├── settings.gradle.kts
├── build.gradle.kts
├── gradle/
│   └── libs.versions.toml   <-- 主工程的版本目录

在 settings.gradle.kts 中添加插件包含：

pluginManagement {
    includeBuild("plugins")
}

这样主工程能找到 plugins/ 里的插件。

编辑主工程的 gradle/libs.versions.toml
新增插件 alias：

[plugins]
pluginA = { id = "com.example.plugina" }
pluginB = { id = "com.example.pluginb" }

2. 创建 plugins 根工程

在 MyApplication/ 下新建目录
右键 MyApplication → New > Directory → 输入 plugins。
在 plugins/ 下新建 settings.gradle.kts，内容如下：

// 1. 插件管理（pluginManagement）
// 这里配置的是“插件仓库”，主要用于解析 `plugins { id("xxx") version "x.y.z" }` 里的插件。
pluginManagement {
    repositories {
        // Gradle 官方插件仓库
        gradlePluginPortal()
        // Android 官方仓库（AGP）
        google()
        // Maven 中央仓库
        mavenCentral()
    }
}

// 2. 依赖解析管理（dependencyResolutionManagement）
// 这里配置的是“普通依赖仓库”，用于解析 build.gradle.kts 中的 `dependencies { implementation(...) }` 等。
dependencyResolutionManagement {
    // 2.1 定义插件工程自己的 version catalog（避免和主工程 libs 冲突）
    versionCatalogs {
        create("pluginLibs") {
            // 从 plugins/gradle/libs.versions.toml 读取依赖版本
            from(files("gradle/libs.versions.toml"))
        }
    }

    // 2.2 配置插件工程使用的依赖仓库
    repositories {
        google()               // Android 官方仓库
        mavenCentral()         // 常用的 Maven 仓库
        gradlePluginPortal()   // Gradle 插件仓库（有些插件会放这里）
    }
}

// 3. 设置插件工程的根工程名称
// 这里的 "plugins" 是插件工程在构建时的 rootProject.name
rootProject.name = "plugins"

// 4. 注册子模块（每个插件都是一个独立的 module）
// 注意：这些 module 对应的是 plugins/ 目录下的 pluginA、pluginB 文件夹
include(":pluginA", ":pluginB")

在 plugins/gradle/ 下新建 libs.versions.toml：

[versions]
kotlin = "2.1.0"
androidGradlePlugin = "8.12.1"

[libraries]
kotlin-gradlePlugin = { group = "org.jetbrains.kotlin", name = "kotlin-gradle-plugin", version.ref = "kotlin" }
android-gradlePlugin = { group = "com.android.tools.build", name = "gradle", version.ref = "androidGradlePlugin" }

3. 创建插件工程pluginA

在 plugins/目录下创建 pluginA目录, 然后在pluginA目录内新建 build.gradle.kts文件，内容如下：

import org.jetbrains.kotlin.gradle.dsl.JvmTarget

plugins {
    // 声明这是一个 Gradle 插件工程（必需）
    // `kotlin-dsl` 插件会启用 Kotlin DSL 插件开发支持，
    // 并且自动为插件工程配置好 classpath 等。
    `kotlin-dsl`
}

group = "com.example.plugin"  
// 插件的 group 名字（类似 maven 坐标的 groupId）。
// 最终生成的插件坐标为：com.example.plugin:pluginA:<version>

java {
    // 配置编译插件工程时使用的 JDK 版本（Java 17）
    sourceCompatibility = JavaVersion.VERSION_17
    targetCompatibility = JavaVersion.VERSION_17
}

kotlin {
    // 配置 Kotlin 编译选项，目标 JVM 版本为 17
    compilerOptions {
        jvmTarget = JvmTarget.JVM_17
    }
}

dependencies {
    // pluginLibs 指向 plugins/gradle/libs.versions.toml 中定义的依赖 catalog
    // 插件工程需要依赖 AGP、Kotlin 插件 API，但只在编译时使用，不需要打包进去
    compileOnly(pluginLibs.android.gradlePlugin)
    compileOnly(pluginLibs.kotlin.gradlePlugin)
}

tasks {
    validatePlugins {
        // 验证插件定义是否正确
        // 开启严格验证，并且遇到警告就直接报错（保证插件发布质量）
        enableStricterValidation = true
        failOnWarning = true
    }
}

gradlePlugin {
    plugins {
        // 注册一个插件，名字随意（只在插件工程内部用）
        register("pluginA") {
            // 插件的唯一 ID（外部工程 apply plugin 时使用的 ID）
            // 这里必须和主工程的 libs.versions.toml 定义一致：
            // [plugins]
            // pluginA = { id = "com.example.plugina" }
            id = "com.example.plugina"

            // 插件的实现类（必须存在且继承 org.gradle.api.Plugin<Project>）
            // 一般写在 src/main/kotlin/com/example/PluginA.kt
            implementationClass = "com.example.PluginA"
        }
    }
}

plugins { kotlin-dsl } 是必须的，否则不能写插件。
group + id + implementationClass 三者是核心，决定了插件的坐标和入口。
pluginLibs.xxx 依赖来自 plugins/gradle/libs.versions.toml，只在插件工程有效

创建PluginA插件代码
在pluginA文件夹下按照下面目录结构创建对应的包名和代码文件

pluginA/
├── build.gradle.kts
└── src/main/kotlin/com/example/
    ├── PluginAPlugin.kt   <-- 插件入口
    └── PluginATask.kt     <-- 插件执行逻辑

打开 PluginATask.kt，写入以下代码：

package com.example

import org.gradle.api.DefaultTask
import org.gradle.api.provider.Property
import org.gradle.api.tasks.Input
import org.gradle.api.tasks.TaskAction
import org.gradle.api.tasks.options.Option

/**
 *  插件的任务
 */
abstract class PluginATask : DefaultTask() {

    // 使用 Property<String> 来定义输入参数
    @get:Input
    @get:Option(option = "message", description = "要打印的消息")
    abstract val message: Property<String>

    @TaskAction
    fun run() {
        val msg = message.orNull ?: "Hello from PluginATask 🎉"
        logger.lifecycle("=================[PluginA]================= $msg")
    }
}

打开PluginA.kt,写入一下代码:

/**
 * 插件入口：注册 PluginATask
 */
class PluginA : Plugin<Project> {
    override fun apply(target: Project) {
        // 注册任务pluginATask
        target.tasks.register("pluginATask", PluginATask::class.java)
    }
}

5. 测试PluginA

在主工程 app/build.gradle.kts应用插件：

plugins {
    alias(libs.plugins.android.application)
    alias(libs.plugins.kotlin.android)
    alias(libs.plugins.kotlin.compose)
    alias(libs.plugins.pluginA)   // 应用本地 PluginA
}

然后在项目根目录下输入命令执行pluginATask

./gradlew app:pluginATask --message="Hello PluginA"

由于我是在App的build.gradle.kts添加的插件, 所以上面的app:代表的就是app模块. 如果是其他模块就换成其他模块的名字.
运行后看到下面的log表示成功了:
在这里插入图片描述