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，供给给外部手动依靠：

  1. 先界说内部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"))
}
  1. 界说三个调集：
//一切的内部库依靠
Map<String, String> allInnerDeps = new HashMap<>()
//一切的非内部依靠：公共渠道库
Map<String, String> allCommonDeps = new HashMap<>()
//库的类型，jar 或者 aar，依靠方法不同
Map<String, String> depType = new HashMap<>()
  1. 剖析依靠，放到不同调集打印、兼并：

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实践及原理分享 – 简书

github.com/kezong/fat-…

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

5. 总结

本文介绍了Android对外输出AAR和不依靠maven，经过兼并多个AAR的方法减少依靠方成本，并介绍了实际运用过程中遇到的问题和处理计划。