阅读 259

Booster 系列之——Assets去重(chóng)

项目地址:github.com/didi/booste…

术语

重复 Assets:具有不同的命名但内容(md5sum)相同的 assets 文件

Assets 去重:去除重复的 assets,使得 APK 中同内容的 assets 仅保留一份

背景

一般 assets 出现大量重复的情况是不多见的,只有像滴滴这样多业务线的大体量 APP 才有可能。然而非常不幸的是,我们确实遇到了这样的问题,虽然对包体积的影响不是很明显(也就几百 KB),但是 几百 KB 对于做字节码优化的同学来说,简直是要了老命了,蚊子肉也是肉啊。

如何去重?

去重的关键在于拦截对 assets 的访问,没错,就是 AssetManager,Booster 的方案就是通过 Transformer 替换 AssetManager 的方法调用指令为 Booster 注入的 ShadowAssetManager,不啰嗦了,先上代码:

public final class ShadowAssetManager {

    /**
     * Shadow Asset => Real Asset
     */
    private static final Map<String, String> DUPLICATED_ASSETS = new ArrayMap<String, String>();

    public static InputStream open(final AssetManager am, final String shadow) throws IOException {
        final String name = DUPLICATED_ASSETS.get(shadow);
        return am.open(null != name && name.trim().length() > 0 ? name : shadow);
    }

    private ShadowAssetManager() {
    }

}
复制代码

就这么简单么?当然不是,上面的 DUPLICATED_ASSETS 还是空的呢,接下来就需要在构建期间构建这个重复 assets 映射表了:

fun BaseVariant.removeDuplicatedAssets(): Map<String, String> {
    val output = mergeAssets.outputDir
    val assets = output.search().groupBy(File::md5).values.filter {
        it.size > 1
    }.map { duplicates ->
        val head = duplicates.first()
        duplicates.takeLast(duplicates.size - 1).map {
            it to head
        }.toMap(mutableMapOf())
    }.reduce { acc, map ->
        acc.putAll(map)
        acc
    }

    assets.keys.forEach {
        it.delete()
    }

    return assets.map {
        it.key.toRelativeString(output) to it.value.toRelativeString(output)
    }.toMap()
}
复制代码

然后,在 Transformer 中修改 ShadowAssetManager,在它的 clinit 中将上面构建好的 assets 映射表添加到 DUPLICATED_ASSETS 中:

class ShadowAssetManagerTransformer : ClassTransformer {

    private lateinit var mapping: Map<String, String>
    override fun transform(context: TransformContext, klass: ClassNode): ClassNode {
        if (klass.name == SHADOW_ASSET_MANAGER) {
            klass.methods.find {
                "${it.name}${it.desc}" == "<clinit>()V"
            }?.let { clinit ->
                klass.methods.remove(clinit)
            }
    
            klass.defaultClinit.let { clinit ->
                clinit.instructions.apply {
                    add(TypeInsnNode(Opcodes.NEW, "java/util/HashMap"))
                    add(InsnNode(Opcodes.DUP))
                    add(MethodInsnNode(Opcodes.INVOKESPECIAL, "java/util/HashMap", "<init>", "()V", false))
                    add(VarInsnNode(Opcodes.ASTORE, 0))
                    mapping.forEach { shadow, real ->
                        add(VarInsnNode(Opcodes.ALOAD, 0))
                        add(LdcInsnNode(shadow))
                        add(LdcInsnNode(real))
                        add(MethodInsnNode(Opcodes.INVOKEVIRTUAL, "java/util/HashMap", "put", "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;", false))
                        add(InsnNode(Opcodes.POP))
                    }
                    add(VarInsnNode(Opcodes.ALOAD, 0))
                    add(MethodInsnNode(Opcodes.INVOKESTATIC, "java/util/Collections", "unmodifiableMap", "(Ljava/util/Map;)Ljava/util/Map;", false))
                    add(FieldInsnNode(Opcodes.PUTSTATIC, SHADOW_ASSET_MANAGER, "DUPLICATED_ASSETS", "Ljava/util/Map;"))
                    add(InsnNode(Opcodes.RETURN))
                }
            }
    
        } else {
            klass.methods.forEach { method ->
                method.instructions?.iterator()?.asSequence()?.filterIsInstance(MethodInsnNode::class.java)?.filter {
                    ASSET_MANAGER == it.owner && "open(Ljava/lang/String;)Ljava/io/InputStream;" == "${it.name}${it.desc}"
                }?.forEach {
                    it.owner = SHADOW_ASSET_MANAGER
                    it.desc = "(L$ASSET_MANAGER;Ljava/lang/String;)Ljava/io/InputStream;"
                    it.opcode = Opcodes.INVOKESTATIC
                }
            }
        }
        
        return klass
    }
    
}
复制代码

以上 ShadowAssetManagerTransformer 的作用便是改写 ShadowAssetManager 的静态块,往 DUPLICATED_ASSETS 中添加重复 assets 的映射关系,反编译后的代码如下:

public final class ShadowAssetManager {

    private static final Map<String, String> DUPLICATED_ASSETS;

    static {
        Map<String, String> var0 = new HashMap<String, String>();
        
        var0.put("assets-1-1", "assets-1");
        var0.put("assets-1-2", "assets-1");
        var0.put("assets-1-3", "assets-1");
        
        var0.put("assets-2-1", "assets-2");
        var0.put("assets-2-2", "assets-2");
        
        ......
        
        var0.put("assets-N-1", "assets-N");
        var0.put("assets-N-2", "assets-N");
        ......
        var0.put("assets-N-n", "assets-N");
        
        DUPLICATED_ASSETS = Collections.unmodifiableMap(var0)
    }

}
复制代码

缺陷

本方案能解决大部分的重复 assets 问题,但是字体除外——因为字体的加载并不是通过 Java 层的 AssetManager 完成的,有兴趣的同学可以研究一下 Typeface.java

总结

Booster 的 assets 去重方案主要分为以下3步:

  1. 根据 assets 的 md5sum 进行分组,建立重复 assets 的映射关系;
  2. 替换所有类中调用 AssetManager.open(String): InputStream 的指令为调用 ShadowAssetManager.open(AssetManager, String): InputStream
  3. 修改 ShadowAssetManager 的静态块,将重复 assets 的映射关系加入到 ShadowAssetManager.DUPLICATED_ASSETS 中;

扩展

通过拦截 AssetManager.open(String): InputStream 不仅可以实现 assets 的去重,还能对 assets 进行压缩,达到减小包体积的目的,原理很简单,主要是利用了 AssetManager.open(String) 方法的返回值是 InputStream 的特点,完全可以用 ZipInputStream 替代,具体思路如下:

  1. mergeAssets 之后,对 assets 进行 ZIP 压缩;
  2. 拦截 AssetManager.open() 方法,在 ShadowAssetManager.open() 方法中返回 ZipInputStream

以上整个过程对于 APP 来说完全透明,简直完美!

关注下面的标签,发现更多相似文章
评论