写给 Android 开发者的 Gradle 系列(四)plugin 实战包体积瘦身

综合技术 2018-05-28 阅读原文

本文由玉刚说写作平台提供写作赞助,版权归玉刚说微信公众号所有

原作者:joker

版权声明:未经玉刚说许可,不得以任何形式转载

本文插件基于 Android Gradle Plugin 3.0.1 版本

前言

日常开发中,为了避免运行时 R 文件反射失败,一般在混淆的时候都会将 R 文件 keep 住,但是因此也会导致包体积有一定的上升,那么有没有减少 R 文件未混淆带来的体积增长呢?

众所周知,Android 中的 R 文件用来存储资源的映射值,而往往一个 apk 中的 R 文件中的字段值的数量是十分庞大的,笔者将一个未进行任何操作的 debug apk 进行解压后发现该文件行数就已超过 1800 行——


为了减少包体积,可以将混淆压缩的话,可以降到500行+左右——



但是混淆后就会存在两个问题——R 文件被混淆了之后,那么资源反射就不能使用了;混淆过程中删除了除 R$styleable.class 以外的其他的 R$*.class ,但是 R$styleable.class 仍然是可以优化的。那么该如何解决这两个问题呢?一个方案是不开启混淆,这显然不太现实;另一个方案是开启混淆,同时在 proguard-rules.pro 中 keep 住 R 文件,再手动删除 R 文件中的字段信息。实际上美丽说团队早期已经开源过一个 thinrPlugin 就是使用方案二,但其针对的是 Gradle plugin 1.0/2.0 的版本,并未对 3.0 做支持,本文将重写该插件,并命名为 thinr3。

写插件前笔者谈及一点前提知识以及插件思路——为什么 R 文件中的字段可以删除?R 文件中的字段分为两种类型,一种是 static final int ,另一种是 static final int[] 。其中, static final int 作为常量在运行时是不会被改变的,那么将这些常量打进 apk 中很明显是多余的,所以实际上打包进 apk 的 R 文件 有很大一部分是冗余的


例如上图中的 R.layout.activity 是完全可以被其所对应的常量替换的,但是由于 keep 住了 R 文件,所以它不会进行替换。

thinr3 的思想就是找到使用 R 字段的地方,如果该字段是常量则将其替换成这个常量所对应的值,并删除 R 文件中该字段,去除冗余——


插件的运行需要对 .class 文件分两次遍历,第一次遍历先是获取到 R.class 文件,遍历其中所有的常量值,封装成键值对用以后面将字段替换成相应的常量;第二次遍历分两种情况,如果是 R 文件那么则将其常量进行删除,如果是其他 .class 文件,则将当中的 R 字段引用根据前面的键值对进行替换。为了对 .class 文件进行操作,需要引入ASM,不了解 ASM 没有关系,本文阐述的插件中运用到 ASM 的部分不多。

那么由此可知,何时何地获取 .class 文件实际上就是整个 task 的核心所在——理论上越靠后 .class 文件将会被修改的风险就越小,笔者选择了在混淆 task (transformClassesAndResourcesWithProguardFor${variant.name.capitalize()})执行之后启用 plugin。原因有两点,其一就是混淆 task 的执行时期已经比较晚了;其二,混淆 task 的产物当中包含所有的 .class 文件信息(Task 接口中包含 outputs 字段,开发者可以通过 Task.outputs.files.files 获取 task 的产物)。

综上所述,将会在 transformClassesAndResourcesWithProguardFor${variant.name.capitalize()} task 执行之后遍历两次获取该 task 的 outputs.files.files ,第一次遍历是找到 R 文件并收集该文件中的 static final int 常量的键值对信息,第二次遍历是根据键值对替换其他文件中的 R 文件字段并删除 R 文件中的该字段。

创建项目

  1. 新建一个项目,将 app/build.gralde 文件下 release 闭包中的 minifyEnabled 设置为 true 以开启 release 包混淆,同时为了避免 R 文件被混淆,需要在 R 文件下添加以下代码以 keep 住 R 文件——

    -keepclassmembers class **.R$* {
    	 public static ;
    }
    -keep class **.R {*;}
    -keep class **.R$* {*;}
    -keep class **.R$*
    -keep class **.R
  2. 新建一个 java module,命名为 buildSrc ,接着将 src/main/java 改成 src/main/groovy,并添加 src/main/resources/META-INF/gradle-plugins 文件夹,在该文件夹下创建 com.joker.thinr3.properties 文件并填写 implementation-class 指向 plugin,最终如下图:


  1. 修改该 module 文件夹下的 build.gradle 文件:

    apply plugin: 'groovy'
    
    dependencies {
        implementation gradleApi()
        implementation localGroovy()
        implementation 'com.android.tools.build:gradle:3.0.1'
    }
    
    allprojects {
        repositories {
            jcenter()
            google ()
        }
    }

由于 Android Gradle Plugin 中依赖了ASM 库,所以在依赖基础库的前提下再依赖 Android Gradle Plugin 即可。

plugin 实操

创建 ThinR3Plugin.groovy ,其源码如下:

package com.joker.thinr3

import com.android.build.gradle.api.ApkVariantOutput
import com.android.build.gradle.api.ApplicationVariant
import org.gradle.api.Plugin
import org.gradle.api.Project

class ThinR3Plugin implements Plugin {
  @Override
  void apply(Project project) {
    project.afterEvaluate {
      project.plugins.withId('com.android.application') {
        project.android.applicationVariants.all { ApplicationVariant variant ->
          variant.outputs.each { ApkVariantOutput variantOutput ->
            if (variantOutput.name.contains("release")) {
              project.tasks.
                  findByName("transformClassesAndResourcesWithProguardFor${variant.name.capitalize()}")
                  .doLast { ProcessAndroidResources task ->
                    task.outputs.files.files.each {
                      collectRInfo()
                    }
                    task.outputs.files.files.each {
                      replaceAndDelRInfo()
                    }
                  }
            }
          }
        }
      }
    }
  }
}

通过 hook project 的 afterEvaluate {} 才能获取到 project 中所有的 task 信息。由于 thinr3 是通过 hook 混淆 task 来实现的,这意味着当前 project 一定得是主工程,所以可以通过 project.plugins.withId('com.android.application') 判断当前工程是否为主工程;一般情况下,插件针对 release 包进行 R 文件缩减,对于其他变种包没有必要,根据官方文档可知 AppExtension 中的 applicationVariants 闭包中包含所有的 apk 变种信息。ApplicationVariant 中有一个字段名为 outputs 的集合(这是 AbstractTask 中的字段),它是该 task 的最终所有变种的集合,一般将 outputs 作为最终的变种输出,说了这么多,实际上仅需要获取到变种的 name 信息,再通过 String#contains("release") 判断当前 apk 是否为 release 包;接下来就是通过 project.tasks.findByName(taskName) 来寻找到混淆 task 并通过 doLast {} 来 hook 它最终的执行阶段;最后,获取混淆 task 产物的方式就是前文提到的 outputs.files.files

那么既然已经获得了混淆之后的产物,那么就可以针对该产物进行操作了。首先毋庸置疑的是最终一定是针对 class 文件进行操作,那么混淆之后的产物是 class 文件么?不妨在 each {} 闭包中输出文件的路径:


很明显前四个文件和 __content__.json 都不是关键文件,唯有 0.jar 可能是,不妨打开 0.jar 看一看——


所以可以确定 0.jar 就是获取 class 信息的地方,那么首先就需要针对 jar 包进行解析,既然仅仅只需要对 jar 包需要解析而没有其他的文件,不妨修改上述代码,使用更加 groovy 的方式直接筛选出 jar 包,修改后代码如下:

it.outputs
	.files
	.files
	.grep { File file -> file.isDirectory() }
	.each { File dir ->
          dir.listFiles({ File file -> file.name.endsWith(".jar") } as FileFilter)
          .each { File jar ->
              // 对 jar 包进行操作
              ASMHelper.collectRInfo(jar)
          }
        }

在 jar 包中收集 R 文件信息的源码如下:

static void collectRInfo(File jar) {
    JarFile jarFile = new JarFile(jar)
    jarFile
        .entries()
        .grep { JarEntry entry -> isRFile(entry.name) }
        .each { JarEntry jarEntry ->
      jarFile.getInputStream(jarEntry).withStream { InputStream inputStream ->
        ClassReader classReader = new ClassReader(inputStream)
        ClassVisitor classVisitor = new ClassVisitor(Opcodes.ASM4) {
          @Override
          FieldVisitor visitField(int access, String name, String desc, String signature,
              Object value) {
            if (value instanceof Integer) {
              map.put(jarEntry.name - ".class" + name, value)
            } else {
              styleableSet.add(jarEntry.name)
            }
            return super.visitField(access, name, desc, signature, value)
          }
        }
        classReader.accept(classVisitor, 0)
      }
    }

    jarFile.close()
  }

通过 JarFile#entries() 获取 jar 包的 Enumeration,Enumeration 当中的每一个对象实际上就是 jar 包中的一个文件。同理,使用 groovy 的写法匹配类名来筛选出 R.class 文件,最终借助 ASM 获取到 R.class 中所有可替换字段的键值对信息。ASM 获取 class 字段的信息可分为四步,第一步通过 byte[]/InputStream/className 来创建 ClassReader 对象;第二步创建 ClassVisitor 类并实现其 visitField() 方法,该方法名已经能够让开发者知道该方法是用来访问类中字段的,前面提到,最终能且只能替换的字段是 static final int 类型的,所以可以根据方法中最后一个参数的类型是否为 Integer 来判断当前字段是否可以被替换,如果可以替换,将其存入 Map 中;第三步是调用 ClassReader#accept(ClassVisitor, flag) 使得 ClassVisitor 通过 ClassReader 来获取 class 文件信息。

收集完信息之后就是要进行替换其他 class 文件中信息,并删除 R.class 中的信息。源码如下:

static void replaceAndDelRInfo(File jar) {
    File newFile = new File(jar.parentFile, jar.name + ".bak")
    JarFile jarFile = new JarFile(jar)
    new JarOutputStream(new FileOutputStream(newFile)).withStream { OutputStream jarOutputStream ->
      jarFile.entries()
          .grep { JarEntry entry -> entry.name.endsWith(".class") }
          .each { JarEntry entry ->
        jarFile.getInputStream(entry).withStream { InputStream inputStream ->
          def fileBytes = inputStream.bytes

          switch (entry) {
            case { isRFileExceptStyleable(entry.name) }:
              fileBytes = null
              break
            case { isRFile(entry.name) }:
              fileBytes = deleteRInfo(fileBytes)
              break
            default:
              fileBytes = replaceRInfo(fileBytes)
              break
          }

          if (fileBytes != null) {
            jarOutputStream.putNextEntry(new ZipEntry(entry.name))
            jarOutputStream.write(fileBytes)
            jarOutputStream.closeEntry()
          }
        }
      }
      jarFile.close()

      jar.delete()
      newFile.renameTo(jar)
    }
  }

创建 0.jar.bak 以备替换原来的 0.jar;同样地,利用 groovy 的语言优势过滤出 .class 文件;获取 0.jar 文件中的 bytes[] 进行修改,共有三种情况:

  • 是 R 文件并且不是 R$styleable.class 文件(例如R$id.class),那么该文件将会被删掉。
  • 是 R$styleable.class 文件,通过 deleteRInfo() 返回利用 ASM 删除了 static final int 字段(保留了 static final int[] 字段)的 class 文件字节。
  • 不是 R 文件并且不是它的内部类文件,那么就是普通 class 文件,通过 replaceRInfo() 返回利用 ASM 和前面包含替换字段信息的 map 替换字段后的普通 class 文件字节。

最后通过 0.jar.bak 的 FileOutputStream 写入一个名字和 jarEntry 名称相同的 ZipEntry (JarEntry 是 ZipEntry 的子类,扩展了证书等属性,但是 class 文件不包含这些内容)并向其中填入前面方法返回的字节。当然,最后不要忘了关闭资源、删除 0.jar、将 0.jar.bak 改名为 0.jar。

  • replaceRInfo() 源码如下:
private static byte[] replaceRInfo(byte[] bytes) {
    ClassReader classReader = new ClassReader(bytes)
    ClassWriter classWriter = new ClassWriter(classReader, 0)
    ClassVisitor classVisitor = new ClassVisitor(Opcodes.ASM4, classWriter) {
      @Override
      MethodVisitor visitMethod(int access, String name, String desc, String signature,
          String[] exceptions) {
        def methodVisitor = super.visitMethod(access, name, desc, signature, exceptions)
        methodVisitor = new MethodVisitor(Opcodes.ASM4, methodVisitor) {
          @Override
          void visitFieldInsn(int opcode, String owner, String name1, String desc1) {
            Integer constantValue = map.get(owner + name1)
            constantValue != null ? super.visitLdcInsn(constantValue) :
                super.visitFieldInsn(opcode, owner, name1, desc1)
          }
        }
        return methodVisitor
      }
    }
    classReader.accept(classVisitor, 0)

    classWriter.toByteArray()
  }

核心内容在 visitMethod() 中,其他的都是固定套路。由于需要修改 class 文件,所以使用原有的 MethodVisitor 肯定是不行的,借助原 MethodVisitor 创建一个新的 MethodVisitor 并返回,覆写新 MethodVisitor 的 visitFieldInsn() 以替换字段值,替换的方式借助前文的 map 当前字段是否存在,如果存在则替换成相应的常量,否则不变(MethodVisitor 的 visitFieldInsn() 不仅会替换方法中的字段,也会替换类中的字段)。

  • deleteRInfo() 源码如下:
private static byte[] deleteRInfo(byte[] fileBytes) {
    ClassReader classReader = new ClassReader(fileBytes)
    ClassWriter classWriter = new ClassWriter(classReader, 0)
    ClassVisitor classVisitor = new ClassVisitor(Opcodes.ASM4, classWriter) {
      @Override
      FieldVisitor visitField(int access, String name, String desc, String signature,
          Object value) {
        value instanceof Integer ? null : super.visitField(access, name, desc, signature, value)
      }
    }
    classReader.accept(classVisitor, 0)

    return classWriter.toByteArray()
  }

只需要借助 ClassVisitor 的 visitField() 来判断当前字段是否为 Integer 类型的,如果是则返回为 null,否则不做任何改动。

后话

参考 ThinRPlugin 的 [README](https://github.com/meili/ThinRPlugin/blob/master/README.zh-cn.md) 可知在蘑菇街 app 的实践上,app 体积缩减了有 1M(40M -> 39M)。所以在项目中如果 id、layout 等文件量比较大的时候,thinr3 的优化能力还是比较可观的。

本文 项目源码请戳我

稀土掘金

责编内容by:稀土掘金阅读原文】。感谢您的支持!

您可能感兴趣的

Android使用Jenkins自动化构建测试打包apk Jenkins这东西搭建起来真是一点也不省心啊,看着别人的教程摸着石头过河,配置的东西有点多啊,稍有不慎,就构建不成功啦!即使步骤跟别人一样也会报各种乱七...
(一)基于阿里云的MQTT远程控制(Android 连接MQTT服务器,ESP8266连接MQTT服... 如果不了解MQTT的可以看这篇文章 http://www.cnblogs.com/yangfengwu/p/7764667.html htt...
10 Things New Android Developers Can Relate To I decided to write about some issues I faced when I started building Android app...
Android适配全面总结(二) 上一篇文章讲了 屏幕适配 http://www.jianshu.com/p/7aa34434ad4d 这一篇文章讲一下版本适配。 ...
开发一个基于 Android系统车载智能APP 很久之前就想做一个车载相关的app、需要实现如下功能: (1)每0.2秒更新一次当前车辆的最新速度值。 (2)可控制性记录行驶里程。 (3)不连接网络...