1 class NuwaPlugin implements Plugin<Project> {
 2     HashSet<String> includePackage
 3     HashSet<String> excludeClass
 4     def debugOn
 5     def patchList = []
 6     def beforeDexTasks = []
 7     private static final String NUWA_DIR = "NuwaDir"
 8     private static final String NUWA_PATCHES = "nuwaPatches"
 9     private static final String MAPPING_TXT = "mapping.txt"
10     private static final String HASH_TXT = "hash.txt"
11     private static final String DEBUG = "debug"
12
13     @Override
14     void apply(Project project) {
15         project.extensions.create("nuwa", NuwaExtension, project)
16         project.afterEvaluate {
17             def extension = project.extensions.findByName("nuwa") as NuwaExtension
18             includePackage = extension.includePackage
19             excludeClass = extension.excludeClass
20             debugOn = extension.debugOn
21            }
22       }
23 }

1 apply plugin: 'com.android.application'
2 apply plugin: 'plugin.test'

1 class NuwaExtension {
2     HashSet<String> includePackage = []
3     HashSet<String> excludeClass = []
4     boolean debugOn = true
5
6     NuwaExtension(Project project) {
7     }
8 }

1     HashSet<String> includePackage
2     HashSet<String> excludeClass
3     def debugOn
4     def patchList = []
5     def beforeDexTasks = []

1 def preDexTask =project.tasks.findByName("preDex${variant.name.capitalize()}”)

1 def dexTask = project.tasks.findByName("dex${variant.name.capitalize()}”)

 1 // 创建打patch的task，这个task负责把对比出有差异的class文件打包成dex
 2 def nuwaPatch = "nuwa${variant.name.capitalize()}Patch”
 3 project.task(nuwaPatch) << {
 4     if (patchDir) {
 5         // 真正负责打包的函数, 函数实现下面会分析
 6         NuwaAndroidUtils.dex(project, patchDir)
 7     }
 8 }
 9 def nuwaPatchTask = project.tasks[nuwaPatch]
10 if(preDexTask) {
11 } else {
12     //创建一个自定义task，负责遍历所有编译好的类，针对每一个class文件注入构造函数，构造函数中引用了一个独立的dex中的类，因为这个类不在当前dex,
13     //所以会防止类被打上ISPREVERIFIED标志
14     def nuwaJarBeforeDex = "nuwaJarBeforeDex${variant.name.capitalize()}”
15     //创建一个自定义task，负责遍历所有编译好的类，针对每一个class文件注入构造函数，构造函数中引用了一个独立的dex中的类，因为这个类不在当前dex,
16     //所以会防止类被打上ISPREVERIFIED标志
17         Set<File> inputFiles = dexTask.inputs.files.files ≈
18         inputFiles.each { inputFile ->
19             // 这里它就能拿到所有编译好的jar包了(jar包不止一个，包括所有support的jar包和依赖的一些jar包还有项目源码打出的jar包,
20             // 总之这些jar包包涵了这个apk中所有的class)。
21             def path = inputFile.absolutePath
22             if (path.endsWith(".jar")) {
23                 // 真正做class注入的函数, 函数实现下面会分析
24                 NuwaProcessor.processJar(hashFile, inputFile, patchDir, hashMap, includePackage, excludeClass)
25             }
26         }
27     }
28     // 因为上一步project.task(nuwaJarBeforeDex)已经创建了nuwaJarBeforeDex的task所以这里通过tasks这个系统成员变量可以拿到真正的task对象。
29     def nuwaJarBeforeDexTask = project.tasks[nuwaJarBeforeDex]
30     // 让自定义task依赖于dexTask的依赖
31     nuwaJarBeforeDexTask.dependsOn dexTask.taskDependencies.getDependencies(dexTask)
32  // 让dexTask依赖于我们的自定义task， 这样就相当于在原来的task链中插入了我们自己的task，在不影响原有流程的情况下可以做我们自己的事情
33     dexTask.dependsOn nuwaJarBeforeDexTask
34     // 让打patch的task依赖于class注入的task， 这样我们可以在控制台手动执行这个task，就可以打出patch文件了。
35     nuwaPatchTask.dependsOn nuwaJarBeforeDexTask
36 }

 1 /**
 2    参数说明：
 3    hashFile: 本次编译所有类的“类名:hash”存放文件
 4    jarFile:  jar包, 调用这个函数的地方会遍历所有的jar包
 5    patchDir:  有变更的文件统一存放到这个目录里
 6    map:  上一次编译所有类的hash映射
 7    includePackage:  额外指定只需要注入这些包下的类
 8    excludeClass： 额外指定不参与注入的类
 9 */
10
11 public static processJar(File hashFile, File jarFile, File patchDir, Map map, HashSet<String> includePackage, HashSet<String> excludeClass) {
12     if (jarFile) {
13         // 先在原始jar同级目录下创建“同名.opt”文件，每注入完成一个类则打到这个opt文件中，
14         // opt文件实际上也是一个jar包，所有类都处理完后将文件后缀opt改为jar替换掉原来的jar
15         def optJar = new File(jarFile.getParent(), jarFile.name + ".opt”)
16         def file = new JarFile(jarFile);
17         Enumeration enumeration = file.entries();
18         // 创建输入opt文件，实际也是一个jar包
19         JarOutputStream jarOutputStream = new JarOutputStream(new FileOutputStream(optJar));
20         while (enumeration.hasMoreElements()) {  // 遍历jar包中的每一个entry
21             JarEntry jarEntry = (JarEntry) enumeration.nextElement();
22             String entryName = jarEntry.getName();
23             ZipEntry zipEntry = new ZipEntry(entryName);
24
25             InputStream inputStream = file.getInputStream(jarEntry);
26             jarOutputStream.putNextEntry(zipEntry);
27
28             if (shouldProcessClassInJar(entryName, includePackage, excludeClass)) {  // 根据一些规则和includePackage与excludeClass判断这个类要不要处理
29                 def bytes = referHackWhenInit(inputStream);  // 拿到这个类的输入流调用这个函数完成字节码注入
30                 jarOutputStream.write(bytes);  // 将注入完成的字节码写入opt文件中
31
32                 def hash = DigestUtils.shaHex(bytes)  // 生成文件hash
33                 hashFile.append(NuwaMapUtils.format(entryName, hash))  将hash值以键值对的形式写入到hash文件中，以便下次对比
34
35                 if (NuwaMapUtils.notSame(map, entryName, hash)) { // 如果这个类和map中上次生成的hash不一样，则认为是修改过的，拷贝到需要最终打包的文件夹中
36                     NuwaFileUtils.copyBytesToFile(bytes, NuwaFileUtils.touchFile(patchDir, entryName))
37                 }
38             } else {
39                 jarOutputStream.write(IOUtils.toByteArray(inputStream));  // 如果这个类不处理则直接写进opt文件
40             }
41             jarOutputStream.closeEntry();
42         }
43         jarOutputStream.close();
44         file.close();
45
46         if (jarFile.exists()) {
47             jarFile.delete()
48         }
49         optJar.renameTo(jarFile)
50     }
51
52 }

 1 /**
 2    负责注入,这里用到了asm框架（asm框架用来修改java字节码文件，非常强大，感兴趣的同学可以搜一下，类似的框架还有Javassist和BCEL）.实际的动作就是给类注入一个无参的构造函数，构造函数里引用了“jiajixin/nuwa/Hack”类，这个类是另外一个dex中的，这个dex需要在application入口处加载，
 3    这样就能保证所有类在用到这个类之前它已经被夹在到内存了，这么做就是为了防止类被打上ISPREVERIFIED标记，从而绕过android对类的检查，保证补丁生效。
 4 */
 5 private static byte[] referHackWhenInit(InputStream inputStream) {
 6     ClassReader cr = new ClassReader(inputStream);
 7     ClassWriter cw = new ClassWriter(cr, 0);
 8     ClassVisitor cv = new ClassVisitor(Opcodes.ASM4, cw) {
 9         @Override
10         public MethodVisitor visitMethod(int access, String name, String desc,
11                                          String signature, String[] exceptions) {
12
13             MethodVisitor mv = super.visitMethod(access, name, desc, signature, exceptions);
14             mv = new MethodVisitor(Opcodes.ASM4, mv) {
15                 @Override
16                 void visitInsn(int opcode) {
17                     if ("<init>".equals(name) && opcode == Opcodes.RETURN) {
18                         super.visitLdcInsn(Type.getType("Lcn/jiajixin/nuwa/Hack;"));  // 引用另一个dex中的类
19                     super.visitInsn(opcode);
20                 }
21             }
22             return mv;
23         }
24
25     };
26     cr.accept(cv, 0);
27     return cw.toByteArray();
28 ｝

 1 /**
 2    NuwaAndroidUtils.dex
 3    对NuwaProcessor.processJar中拷贝到patch文件夹的类执行打包   操作，这里用到了build-tools中的命令行。
 4    参数说明：
 5    project: 工程对象，从插件那里传过来的
 6    classDir:  包含需要打包的类的文件夹
 7 */
 8
 9 public static dex(Project project, File classDir) {
10     if (classDir.listFiles().size()) {
11         def sdkDir
12
13         Properties properties = new Properties()
14         File localProps = project.rootProject.file("local.properties")
15         if (localProps.exists()) {
16             properties.load(localProps.newDataInputStream())
17             sdkDir = properties.getProperty("sdk.dir")
18         } else {
19             sdkDir = System.getenv("ANDROID_HOME")
20         }
21         if (sdkDir) {
22             def cmdExt = Os.isFamily(Os.FAMILY_WINDOWS) ? '.bat' : ''
23             def stdout = new ByteArrayOutputStream()
24             project.exec {
25                 commandLine "${sdkDir}/build-tools/${project.android.buildToolsVersion}/dx${cmdExt}",
26                         '--dex',
27                         "--output=${new File(classDir.getParent(), PATCH_NAME).absolutePath}",
28                         "${classDir.absolutePath}"
29                 standardOutput = stdout
30             }
31             def error = stdout.toString().trim()
32             if (error) {
33                 println "dex error:" + error
34             }
35         } else {
36             throw new InvalidUserDataException('$ANDROID_HOME is not defined')
37         }
38     }
39 }

1 gradlew clean nuwaReleasePatch -P NuwaDir=/Users/GaoGao/nuwa