多个AAR打包成一个AAR

标签：name 多个 dep aar result key AAR 打包 SDK

1. 背景介绍

公司日常开发基于自建的Maven服务器，不对外开放，公司内开发的SDK都传到私服，经过这么多年的迭代已经有上百个包，前段时间有其他公司需要依赖内部某个SDK，而这个SDK有依赖了公司好多SDK，但是公司内网权限无法对外开放，所以无法使用Maven方式对外提供依赖，如果基于AAR方式，对外提供十几个AAR不仅不友好，而且内部也不好维护迭代。

2. 解决思路及办法

市面上有一套开源的合并AAR的方案，合并AAR主要的步骤：

AndroidManifest合并
Classes合并
Jar合并
Res合并
Assets合并
Jni合并
R.txt合并
R.class合并
DataBinding合并
Proguard合并
Kotlin module合并

这些都有对应Gradle task，具体方案可以看对应源码：adwiv/android-fat-aar目前已不再维护，gradle不支持高版本，kezong/fat-aar-android虽然也不在维护，但是已经适配了AGP 3.0 - 7.1.0，Gradle 4.9 - 7.3。

3. 遇到问题

3.1 资源冲突

如果library和module中含有同名的资源(比如 string/app_name)，编译将会报duplication resources的相关错误，有两种方法可以解决这个问题：

将library以及module中的资源都加一个前缀来避免资源冲突（不是所有历史版本的SDK都遵循这个规范）；
在gradle.properties中添加android.disableResourceValidation=true可以忽略资源冲突的编译错误，程序会采用第一个找到的同名资源作为实际资源（资源覆盖可能会导致某些错误）

3.2 动态库冲突

在application中动态库冲突可以使用pickFirst指定第一个，但是这个无法适用于library中。

关于packagingOptions常见的设置项有exclude、pickFirst、doNotStrip、merge。

1. exclude，过滤掉某些文件或者目录不添加到APK中，作用于APK，不能过滤aar和jar中的内容。

比如：

packagingOptions {
    exclude 'META-INF/**'
    exclude 'lib/arm64-v8a/libopus.so'
}

2. pickFirst，匹配到多个相同文件，只提取第一个。只作用于APK，不能过滤aar和jar中的文件。

比如：

 packagingOptions {
    pickFirst "lib/armeabi-v7a/libopus.so"
    pickFirst "lib/armeabi-v7a/libopus.so" 
 }

3. doNotStrip，可以设置某些动态库不被优化压缩。

比如：

 packagingOptions{
    doNotStrip "*/armeabi/*.so"
    doNotStrip "*/armeabi-v7a/*.so"
 }

4. merge，将匹配的文件都添加到APK中，和pickFirst有些相反，会合并所有文件。

比如：

packagingOptions {
    merge '**/LICENSE.txt'
    merge '**/NOTICE.txt'
}

最后针对包含冲突动态库的SDK，单独对外依赖，在application中pickfirst，暂时没有特别好的方法。

3.3 外部依赖库

SDK中有些依赖的是外部公共仓库，比如OKHTTP等，如果都合并到同一的AAR，会导致外部依赖不够灵活，我们的思路是合并的时候不合并外部SDK，只打包公司内部SDK,并打印外部依赖的SDK，提供给外部手动依赖：

先定义内部SDK规则方法：

static boolean isInnerDep(RenderableDependency dep) {
    return (dep.name.contains("com.xxx")
        || dep.name.contains("com.xxxxx")
        || dep.name.contains("com.xxxxxxx")
        || dep.name.contains("com.xxxxxxxx"))
}

定义三个集合：

//所有的内部库依赖
Map<String, String> allInnerDeps = new HashMap<>()
//所有的非内部依赖：公共平台库
Map<String, String> allCommonDeps = new HashMap<>()
//库的类型，jar 或者 aar，依赖方式不同
Map<String, String> depType = new HashMap<>()

分析依赖，放到不同集合打印、合并：


void collectDependencies(Map<String, String> commonDependencies, Map<String, String> innerDependencies, RenderableDependency result) {
    String depName = result.name.substring(0, result.name.lastIndexOf(":"))
//    println "denName = " + depName
    String version = result.name.substring(result.name.lastIndexOf(":") + 1, result.name.length())

    if (result.getChildren() != null && result.getChildren().size() > 0) {
        if (isInnerDep(result) && !isExcludeDep(result)) {
            tryToAdd(innerDependencies, depName, version)
            result.getChildren().each {
                res ->
                    collectDependencies(commonDependencies, innerDependencies, res)
            }
        } else {
            tryToAdd(commonDependencies, depName, version)
        }
    } else {
        if (isInnerDep(result) && !isExcludeDep(result)) {
            tryToAdd(innerDependencies, depName, version)
        } else {
            tryToAdd(commonDependencies, depName, version)
        }
    }
}

configurations.findAll { conf ->
    return conf.name == "implementation" || conf.name == "api"
}.each {
    conf ->
//        println "--------------"+conf.name
        def copyConf = conf.copy()
        copyConf.setCanBeResolved(true)
        copyConf.each {
            file ->
                String s = file.name.substring(0, file.name.lastIndexOf("."))
                String key
                if (s.contains("-SNAPSHOT")) {
                    String t = (s.substring(0, s.lastIndexOf("-SNAPSHOT")))
                    key = t.substring(0, t.lastIndexOf("-"))
                } else {
                    key = s.substring(0, s.lastIndexOf("-"))
                }
                String value = file.name.substring(file.name.lastIndexOf("."), file.name.length())
                depType.put(key, value)
        }
        ResolutionResult result = copyConf.getIncoming().getResolutionResult()
        RenderableDependency depRoot = new RenderableModuleResult(result.getRoot())
        depRoot.getChildren().each {
            d ->
                collectDependencies(allCommonDeps, allInnerDeps, d)
        }

}
println("==================内部依赖====================")

allInnerDeps.each {
    dep ->
        println dep.key + ":" + dep.value

        dependencies {
            String key = dep.key.substring(dep.key.lastIndexOf(":") + 1, dep.key.length())
            String type = depType.get(key)
            if (type == ".aar") {
                embed(dep.key + ":" + dep.value + "@aar")
            } else {
                embed(dep.key + ":" + dep.value)
            }
        }
}

println "=====================正确使用 sdk，需要添加如下依赖========================"
allCommonDeps.each {
    dep ->
        println "api " + "\"" + dep.key + ":" + dep.value + "\""
}

3.4 对外提供多个业务SDK

我们提供一个同一AAR后，另一个业务也要对外提供SDK，这样有公共依赖的就会有冲突问题，如果都合并成一个，某一方改动，势必会引起另一方回归测试，最后抽取公共的sdk合并成一个aar，各自业务合并各自的AAR。

4. 参考资料

使用fat-aar编译打包多个aar库 - 简书

fat-aar实践及原理分享 - 简书

https://github.com/kezong/fat-aar-android

GitHub - adwiv/android-fat-aar: Gradle script that allows you to merge and embed dependencies in generted aar file

5. 总结

本文介绍了Android对外输出AAR和不依赖maven，通过合并多个AAR的方式减少依赖方成本，并介绍了实际使用过程中遇到的问题和解决方案。

标签：name,多个,dep,aar,result,key,AAR,打包,SDK
From： https://blog.csdn.net/sjw890821sjw/article/details/139578616