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

原作者：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 <fields>;
   }
   -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，最终如下图：

3. 修改该 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<Project> {
  @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，否则不做任何改动。

后话

本文项目源码请戳我