适配 AGP8.5 版本，版本依赖管理（五）

骑车吗，累了吗？到哪里都能躺下

AGP7+

loadAddDependencies

加载所有依赖项

implementation

使用 implementation 添加某个依赖

excludedDependencies

排除指定模块

forceDependencies

强制指定模块

existAllDependence

判断某依赖是否存在

import groovy.json.JsonSlurper
import org.gradle.api.Project
import org.gradle.api.artifacts.DependencyResolveDetails


class PluginDependenceUtils {

    /**
     * 加载所有依赖项
     * - 遍历所有项目配置：project.configurations.all
     * - 解析依赖信息：resolutionStrategy.eachDependency
     *
     *
     * @param project
     * @param callback
     */
    static void loadAddDependencies(Project project, DependenciesCallback callback) {
        def dp = new ArrayList()
        project.configurations.all {
            resolutionStrategy.eachDependency { DependencyResolveDetails details ->
                String module = details.requested.module.group + ":" + details.requested.module.name + ":" + details.requested.version
                if (!dp.contains(module)) {
                    dp.add(module)
                }

                callback.onResult(dp)
            }
        }
    }

    /**
     * 使用 implementation 添加某个依赖
     * - project.dependencies.add("implementation", project.dependencies.create(it))
     *
     *
     * @param project
     * @param dependenciesList
     */
    static void implementation(Project project, List<String> dependenciesList) {
        if (project == null || CommUtils.isEmptyOrNoExists(dependenciesList)) {
            return
        }

        dependenciesList.each {
            if (it != null && !it.trim().isEmpty()) {
                def split = it.split(":")
                if (!CommUtils.isEmptyOrNoExists(split) && split.length == 3) {
                    project.dependencies.add("implementation", project.dependencies.create(it))
                }
            }
        }
    }

    /**
     * 排除指定模块
     * - 遍历所有项目配置：project.configurations.all
     * - 解析依赖：resolutionStrategy
     * - 排除模块：exclude group: it.first, module: it.second
     *
     *
     * @param project
     * @param excludeList
     */
    static void excludedDependencies(Project project, List<Pair> excludeList) {
        if (CommUtils.isEmptyOrNoExists(excludeList)) {
            return
        }

        project.configurations.all {
            resolutionStrategy {
                excludeList.each {
                    exclude group: it.first, module: it.second
                }
            }
        }
    }

    /**
     * 强制指定模块（版本）
     * - 遍历所有项目配置：project.configurations.all
     * - 强制指定版本：resolutionStrategy.force it
     *
     *
     * @param project
     * @param assignList
     * @param allDependenciesList
     */
    static void forceDependencies(Project project, List<String> assignList) {
        if (CommUtils.isEmptyOrNoExists(assignList)) {
            return
        }

        project.configurations.all {
            assignList.each {
                resolutionStrategy.force it
            }
        }
    }
    /**
     * 判断某依赖是否存在
     *
     * @param project
     * @param group
     * @param name
     * @return
     */
    static boolean existAllDependence(Project project, String group, String name) {
        existAllDependence(project, group, name, null)
    }

    /**
     * 判断某依赖是否存在
     * - 获取所有依赖： project.configurations.getByName("implementation").dependencies
     * - 遍历、解析依赖信息
     *
     *
     * @param project
     * @param group
     * @param name
     * @param version
     * @return
     */
    static boolean existAllDependence(Project project, String group, String name, String version) {
        if (CommUtils.isEmptyOrNoExists(group) || CommUtils.isEmptyOrNoExists(name)) {
            return false
        }
        def dependencies = project.configurations.getByName("implementation").dependencies
        if (dependencies.empty) {
            return false
        }

        boolean existDep = false
        dependencies.each {
            if (!CommUtils.isEmptyOrNoExists(it.name) && !CommUtils.isEmptyOrNoExists(it.group)) {
                if (!CommUtils.isEmptyOrNoExists(version)) {
                    if (it.name == name && it.group == group && it.version == version) {
                        existDep = true
                    }
                } else {
                    if (it.name == name && it.group == group) {
                        existDep = true
                    }
                }
            }
        }

        return existDep
    }
}

AGP8+

loadAddDependencies

加载所有依赖项

implementation

使用 implementation 添加某个依赖

excludedDependencies

排除指定模块

forceDependencies

强制指定模块

existAllDependence

判断某依赖是否存在

getForcedDependencies

获取强制指定依赖列表

import com.android.build.api.variant.AndroidComponentsExtension
import kotlinx.serialization.json.Json
import org.gradle.api.Project
import org.gradle.api.artifacts.Configuration
import org.gradle.api.internal.artifacts.ivyservice.dependencysubstitution.DefaultDependencyResolveDetails

class PluginDependenceUtils {

    companion object {
    
        @JvmStatic
        private val forcedModuleMap = mutableSetOf<String>()

        @JvmStatic
        fun clearCollect() {
            if (forcedModuleMap.isNotEmpty()) {
                forcedModuleMap.clear()
            }
        }

        /**
         * 获取强制指定依赖的列表
         * - 获得 AndroidComponentsExtension：project.extensions.getByType(AndroidComponentsExtension::class.java)
         * - 遍历变体 components：variants.components.forEach
         * - 获得、遍历强制模块：component.runtimeConfiguration.resolutionStrategy.forcedModules
         *
         */
        @JvmStatic
        fun getForcedDependencies(project: Project, callback: DependenciesCallback) {
            val dp = ArrayList<String>()
            val androidExt =
                project.extensions.getByType(AndroidComponentsExtension::class.java)
            androidExt.onVariants { variants ->
                variants.components.forEach { component ->
                    component.runtimeConfiguration.resolutionStrategy.forcedModules.forEach {
                        val module = it.group + ":" + it.name + ":" + it.version
                        if (!dp.contains(module)) {
                            dp.add(module)
                        }

                        callback.onResult(dp)
                    }
                }
            }
        }

        /**
         * 加载所有依赖
         * - 获得 AndroidComponentsExtension
         * - 变体遍历：variants.components.forEach
         * - 解析依赖：component.runtimeConfiguration.resolutionStrategy.eachDependency
         *
         */
        @JvmStatic
        fun loadAddDependencies(project: Project, callback: DependenciesCallback) {
            val dp = ArrayList<String>()
            val androidExt =
                project.extensions.getByType(AndroidComponentsExtension::class.java)
            androidExt.onVariants { variants ->
                variants.components.forEach { component ->
                    component.runtimeConfiguration.resolutionStrategy.eachDependency {
                        val details = it as DefaultDependencyResolveDetails
                        val module =
                            details.requested.module.group + ":" + details.requested.module.name + ":" + details.requested.version

                        if (!dp.contains(module)) {
                            dp.add(module)
                        }

                        callback.onResult(dp)
                    }
                }
            }
        }

        @JvmStatic
        fun parserDependencies(str: String): List<Pair<String, String>> {
            if (CommUtils.isEmptyOrNoExists(str)) {
                return emptyList()
            }

            val list = Json.decodeFromString<List<String>>(str)
            if (list.isEmpty()) {
                return emptyList()
            }

            val result = mutableListOf<Pair<String, String>>()
            for (item in list) {
                if (!CommUtils.isEmptyOrNoExists(item) && item.contains(":")) {
                    val split = item.split(":")
                    if (split.size == 2) {
                        result.add(Pair(split[0], split[1]))
                    }
                }
            }
            return result
        }

        /**
         * 使用 implementation 添加某个依赖
         * - 直接添加依赖：project.dependencies.add
         * - 模块创建：project.dependencies.create(module)
         *
         */
        @JvmStatic
        fun implementation(project: Project, module: String) {
            if (module.isEmpty()) {
                return
            }
            project.dependencies.add(
                "implementation",
                project.dependencies.create(module)
            )
        }

        /**
         * 使用 implementation 添加某个依赖
         * - 直接添加依赖：project.dependencies.add
         * - 模块创建：project.dependencies.create(module)
         *
         */
        @JvmStatic
        fun implementation(project: Project, dependenciesList: List<String>) {
            if (CommUtils.isEmptyOrNoExists(dependenciesList)) {
                return
            }

            dependenciesList.forEach {
                if (it.trim().isNotEmpty()) {
                    val split = it.split(":")
                    if (!CommUtils.isEmptyOrNoExists(split) && split.size == 3) {
                        project.dependencies.add("implementation", project.dependencies.create(it))
                    }
                }
            }
        }

        /**
         * 排除指定模块
         * - 解析项目配置：project.configurations.all
         * - 直接排除指定依赖：config.exclude
         *
         */
        @JvmStatic
        fun excludedDependencies(project: Project, excludeList: List<Pair<String, String>>) {
            if (CommUtils.isEmptyOrNoExists(excludeList)) {
                return
            }

            val excludes = mutableListOf<ExclusionRuleData>()
            excludeList.forEach {
                excludes.add(ExclusionRuleData(it.first, it.second))
            }

            project.configurations.all { config: Configuration ->
                excludes.forEach { exc ->
                    config.exclude(exc.toMap())
                }
            }
        }

        /**
         * 强制指定模块
         * - 解析项目配置：project.configurations.all
         * - 解析依赖：config.resolutionStrategy
         * - 直接指定依赖：rule.force(it)
         *
         */
        @JvmStatic
        fun forceDependencies(project: Project, assignList: List<String>) {
            if (CommUtils.isEmptyOrNoExists(assignList)) {
                return
            }

            project.configurations.all { config: Configuration ->
                config.resolutionStrategy { rule ->
                    assignList.forEach {
                        rule.force(it)
                        if (!forcedModuleMap.contains(it)) {
                            forcedModuleMap.add(it)
                        }
                    }
                }
            }
        }

        /**
         * 判断某依赖是否存在
         */
        @JvmStatic
        fun existAllDependence(project: Project, group: String, name: String): Boolean {
            return existAllDependence(project, group, name, null)
        }


        /**
         * 获取到的没有 component.runtimeConfiguration.resolutionStrategy 全
         * 判断某依赖是否存在
         * - 解析项目依赖：project.configurations.getByName("implementation").dependencies
         * 
         */
        @JvmStatic
        fun existAllDependence(
            project: Project,
            group: String,
            name: String,
            version: String?
        ): Boolean {
            if (CommUtils.isEmptyOrNoExists(group) || CommUtils.isEmptyOrNoExists(name)) {
                return false
            }

            val dependencies = project.configurations.getByName("implementation").dependencies
            if (dependencies.isEmpty()) {
                return false
            }

            var existDep = false
            dependencies.forEach {
                if (!CommUtils.isEmptyOrNoExists(it.name) && !CommUtils.isEmptyOrNoExists(it.group)) {
                    if (!CommUtils.isEmptyOrNoExists(version)) {
                        if (it.name == name && it.group == group && it.version == version) {
                            existDep = true
                        }
                    } else {
                        if (it.name == name && it.group == group) {
                            existDep = true
                        }
                    }
                }
            }

            return existDep
        }
    }
}