Matrix-ASM插桩插件解析

public static void inject(Project project, MatrixTraceExtension extension, VariantScope variantScope) {
    ...
    try {
        String[] hardTask = getTransformTaskName(extension.getCustomDexTransformName(), variant.getName());
        for (Task task : project.getTasks()) {
            for (String str : hardTask) {
                if (task.getName().equalsIgnoreCase(str) && task instanceof TransformTask) {
                    TransformTask transformTask = (TransformTask) task;
                    Log.i(TAG, "successfully inject task:" + transformTask.getName());
                    Field field = TransformTask.class.getDeclaredField("transform");
                    field.setAccessible(true);
                    field.set(task, new MatrixTraceTransform(config, transformTask.getTransform()));
                    break;
                }
            }
        }
    } catch (Exception e) {
        Log.e(TAG, e.toString());
    }
}

private static String[] getTransformTaskName(String customDexTransformName, String buildTypeSuffix) {
    if (!Util.isNullOrNil(customDexTransformName)) {
        return new String[]{customDexTransformName + "For" + buildTypeSuffix};
    } else {
        String[] names = new String[]{
                "transformClassesWithDexBuilderFor" + buildTypeSuffix,
                "transformClassesWithDexFor" + buildTypeSuffix,
        };
        return names;
    }
}

String taskName = scope.getTaskName(getTaskNamePrefix(transform));

@NonNull
private static String getTaskNamePrefix(@NonNull Transform transform) {
    StringBuilder sb = new StringBuilder(100);
    sb.append("transform");

    Iterator<ContentType> iterator = transform.getInputTypes().iterator();
    // there's always at least one
    sb.append(capitalize(iterator.next().name().toLowerCase(Locale.getDefault())));
    while (iterator.hasNext()) {
        sb.append("And").append(capitalize(
                iterator.next().name().toLowerCase(Locale.getDefault())));
    }

    sb.append("With").append(capitalize(transform.getName())).append("For");

    return sb.toString();
}

//////////////////
@Override
@NonNull
public String getTaskName(@NonNull String prefix) {
    return getTaskName(prefix, "");
}

@Override
@NonNull
public String getTaskName(@NonNull String prefix, @NonNull String suffix) {
    return prefix + StringHelper.capitalize(getVariantOutputData().getFullName()) + suffix;
}
//////////////////

@Override
public void transform(TransformInvocation transformInvocation) throws TransformException, InterruptedException, IOException {
    super.transform(transformInvocation);
    long start = System.currentTimeMillis();
    try {
        doTransform(transformInvocation); // hack
    } catch (ExecutionException e) {
        e.printStackTrace();
    }
    long cost = System.currentTimeMillis() - start;
    long begin = System.currentTimeMillis();
    origTransform.transform(transformInvocation);
    long origTransformCost = System.currentTimeMillis() - begin;
    Log.i("Matrix." + getName(), "[transform] cost time: %dms %s:%sms MatrixTraceTransform:%sms", System.currentTimeMillis() - start, origTransform.getClass().getSimpleName(), origTransformCost, cost);
}

public void trace(Map<File, File> srcFolderList, Map<File, File> dependencyJarList) throws ExecutionException, InterruptedException {
    List<Future> futures = new LinkedList<>();
    traceMethodFromSrc(srcFolderList, futures);
    traceMethodFromJar(dependencyJarList, futures);
    for (Future future : futures) {
        future.get();
    }
    futures.clear();
}

private void traceMethodFromSrc(Map<File, File> srcMap, List<Future> futures) {
    if (null != srcMap) {
        for (Map.Entry<File, File> entry : srcMap.entrySet()) {
            futures.add(executor.submit(new Runnable() {
                @Override
                public void run() {
                    innerTraceMethodFromSrc(entry.getKey(), entry.getValue());
                }
            }));
        }
    }
}

private void innerTraceMethodFromSrc(File input, File output) {

    ArrayList<File> classFileList = new ArrayList<>();
    if (input.isDirectory()) {
        listClassFiles(classFileList, input);
    } else {
        classFileList.add(input);
    }

    for (File classFile : classFileList) {
        InputStream is = null;
        FileOutputStream os = null;
        try {
            final String changedFileInputFullPath = classFile.getAbsolutePath();
            final File changedFileOutput = new File(changedFileInputFullPath.replace(input.getAbsolutePath(), output.getAbsolutePath()));
            if (!changedFileOutput.exists()) {
                changedFileOutput.getParentFile().mkdirs();
            }
            changedFileOutput.createNewFile();

            if (MethodCollector.isNeedTraceFile(classFile.getName())) {
                is = new FileInputStream(classFile);
                ClassReader classReader = new ClassReader(is);
                ClassWriter classWriter = new ClassWriter(ClassWriter.COMPUTE_MAXS);
                ClassVisitor classVisitor = new TraceClassAdapter(Opcodes.ASM5, classWriter);
                classReader.accept(classVisitor, ClassReader.EXPAND_FRAMES);
                is.close();

                if (output.isDirectory()) {
                    os = new FileOutputStream(changedFileOutput);
                } else {
                    os = new FileOutputStream(output);
                }
                os.write(classWriter.toByteArray());
                os.close();
            } else {
                FileUtil.copyFileUsingStream(classFile, changedFileOutput);
            }
        } catch (Exception e) {
            Log.e(TAG, "[innerTraceMethodFromSrc] input:%s e:%s", input.getName(), e);
            try {
                Files.copy(input.toPath(), output.toPath(), StandardCopyOption.REPLACE_EXISTING);
            } catch (Exception e1) {
                e1.printStackTrace();
            }
        } finally {
            try {
                is.close();
                os.close();
            } catch (Exception e) {
                // ignore
            }
        }
    }
}

ClassReader classReader = new ClassReader(is);
ClassWriter classWriter = new ClassWriter(ClassWriter.COMPUTE_MAXS);
ClassVisitor classVisitor = new TraceClassAdapter(Opcodes.ASM5, classWriter);
classReader.accept(classVisitor, ClassReader.EXPAND_FRAMES);

private class TraceClassAdapter extends ClassVisitor {

    private String className;
    private boolean isABSClass = false;
    private boolean hasWindowFocusMethod = false;
    private boolean isActivityOrSubClass;
    private boolean isNeedTrace;

    TraceClassAdapter(int i, ClassVisitor classVisitor) {
        // i是指ASM的版本号，此处为5
        super(i, classVisitor);
    }

    /**
     * 遍历到类的header时被调用
     * version – the class version.
     * access – the class's access flags (see Opcodes). This parameter also indicates if the class is deprecated.
     * name – the internal name of the class (see getInternalName).
     * signature – the signature of this class. May be null if the class is not a generic one, and does not extend or implement generic classes or interfaces.
     * me – the internal of name of the super class (see getInternalName). For interfaces, the super class is Object. May be null, but only for the Object class.
     * interfaces – the internal names of the class's interfaces (see getInternalName). May be null.
     */
    @Override
    public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
        super.visit(version, access, name, signature, superName, interfaces);
        this.className = name;
        this.isActivityOrSubClass = isActivityOrSubClass(className, collectedClassExtendMap);
        this.isNeedTrace = MethodCollector.isNeedTrace(configuration, className, mappingCollector);
        if ((access & Opcodes.ACC_ABSTRACT) > 0 || (access & Opcodes.ACC_INTERFACE) > 0) {
            this.isABSClass = true;
        }
    }

    /**
     * 遍历到方法时被调用
     * access – the method's access flags (see Opcodes). This parameter also indicates if the method is synthetic and/or deprecated.
     * name – the method's name.
     * desc – the method's descriptor (see Type).
     * signature – the method's signature. May be null if the method parameters, return type and exceptions do not use generic types.
     * exceptions – the internal names of the method's exception classes (see getInternalName). May be null.
     */
    @Override
    public MethodVisitor visitMethod(int access, String name, String desc,
                                        String signature, String[] exceptions) {
        if (isABSClass) {
            return super.visitMethod(access, name, desc, signature, exceptions);
        } else {
            if (!hasWindowFocusMethod) {
                hasWindowFocusMethod = MethodCollector.isWindowFocusChangeMethod(name, desc);
            }
            MethodVisitor methodVisitor = cv.visitMethod(access, name, desc, signature, exceptions);
            return new TraceMethodAdapter(api, methodVisitor, access, name, desc, this.className,
                    hasWindowFocusMethod, isActivityOrSubClass, isNeedTrace);
        }
    }

    /**
     * 类遍历结束时被调用
     */
    @Override
    public void visitEnd() {
        if (!hasWindowFocusMethod && isActivityOrSubClass && isNeedTrace) {
            insertWindowFocusChangeMethod(cv, className);
        }
        super.visitEnd();
    }
}

private void insertWindowFocusChangeMethod(ClassVisitor cv, String classname) {
    // public void onWindowFocusChanged (boolean)
    MethodVisitor methodVisitor = cv.visitMethod(Opcodes.ACC_PUBLIC, TraceBuildConstants.MATRIX_TRACE_ON_WINDOW_FOCUS_METHOD,
            TraceBuildConstants.MATRIX_TRACE_ON_WINDOW_FOCUS_METHOD_ARGS, null, null);
    // {
    methodVisitor.visitCode();
    // this
    methodVisitor.visitVarInsn(Opcodes.ALOAD, 0);
    // boolean
    methodVisitor.visitVarInsn(Opcodes.ILOAD, 1);
    // super.onWindowFocusChanged(boolean)
    methodVisitor.visitMethodInsn(Opcodes.INVOKESPECIAL, TraceBuildConstants.MATRIX_TRACE_ACTIVITY_CLASS, TraceBuildConstants.MATRIX_TRACE_ON_WINDOW_FOCUS_METHOD,
            TraceBuildConstants.MATRIX_TRACE_ON_WINDOW_FOCUS_METHOD_ARGS, false);
    // com/tencent/matrix/trace/core/AppMethodBeat.at(this, boolean)
    traceWindowFocusChangeMethod(methodVisitor, classname);
    // 返回语句
    methodVisitor.visitInsn(Opcodes.RETURN);
    methodVisitor.visitMaxs(2, 2);
    methodVisitor.visitEnd();
}

private class TraceMethodAdapter extends AdviceAdapter {

    private final String methodName;
    private final String name;
    private final String className;
    private final boolean hasWindowFocusMethod;
    private final boolean isNeedTrace;
    private final boolean isActivityOrSubClass;

    protected TraceMethodAdapter(int api, MethodVisitor mv, int access, String name, String desc, String className,
                                    boolean hasWindowFocusMethod, boolean isActivityOrSubClass, boolean isNeedTrace) {
        super(api, mv, access, name, desc);
        TraceMethod traceMethod = TraceMethod.create(0, access, className, name, desc);
        this.methodName = traceMethod.getMethodName();
        this.hasWindowFocusMethod = hasWindowFocusMethod;
        this.className = className;
        this.name = name;
        this.isActivityOrSubClass = isActivityOrSubClass;
        this.isNeedTrace = isNeedTrace;

    }

    @Override
    protected void onMethodEnter() {
        // 插入 void com/tencent/matrix/trace/core/AppMethodBeat.i(int)
        TraceMethod traceMethod = collectedMethodMap.get(methodName);
        if (traceMethod != null) {
            traceMethodCount.incrementAndGet();
            mv.visitLdcInsn(traceMethod.id);
            mv.visitMethodInsn(INVOKESTATIC, TraceBuildConstants.MATRIX_TRACE_CLASS, "i", "(I)V", false);
        }
    }

    @Override
    protected void onMethodExit(int opcode) {
        TraceMethod traceMethod = collectedMethodMap.get(methodName);
        if (traceMethod != null) {
            if (hasWindowFocusMethod && isActivityOrSubClass && isNeedTrace) {
                TraceMethod windowFocusChangeMethod = TraceMethod.create(-1, Opcodes.ACC_PUBLIC, className,
                        TraceBuildConstants.MATRIX_TRACE_ON_WINDOW_FOCUS_METHOD, TraceBuildConstants.MATRIX_TRACE_ON_WINDOW_FOCUS_METHOD_ARGS);
                if (windowFocusChangeMethod.equals(traceMethod)) {
                    // com/tencent/matrix/trace/core/AppMethodBeat.at(this, boolean)
                    traceWindowFocusChangeMethod(mv, className);
                }
            }

            traceMethodCount.incrementAndGet();
            // 插入 void com/tencent/matrix/trace/core/AppMethodBeat.o(int)
            mv.visitLdcInsn(traceMethod.id);
            mv.visitMethodInsn(INVOKESTATIC, TraceBuildConstants.MATRIX_TRACE_CLASS, "o", "(I)V", false);
        }
    }
}

void removeUnusedResources(String originalApk, String rTxtFile, SigningConfig signingConfig) {
    ZipOutputStream zipOutputStream = null;
    boolean needSign = project.extensions.matrix.removeUnusedResources.needSign;
    boolean shrinkArsc = project.extensions.matrix.removeUnusedResources.shrinkArsc;
    String apksigner = project.extensions.matrix.removeUnusedResources.apksignerPath;
    if (needSign) {
        if (Util.isNullOrNil(apksigner)) {
            throw new GradleException("need sign apk but apksigner not found!");
        } else if (! new File(apksigner).exists()) {
            throw new GradleException( "need sign apk but apksigner " + apksigner + " was not exist!");
        } else if (signingConfig == null) {
            throw new GradleException("need sign apk but signingConfig not found!");
        }
    }
    ...
}

File inputFile = new File(originalApk);
Set<String> ignoreRes = project.extensions.matrix.removeUnusedResources.ignoreResources;
for (String res : ignoreRes) {
    ignoreResources.add(Util.globToRegexp(res));
}
Set<String> unusedResources = project.extensions.matrix.removeUnusedResources.unusedResources;
Iterator<String> iterator = unusedResources.iterator();
String res = null;
while (iterator.hasNext()) {
    res = iterator.next();
    if (ignoreResource(res)) {
        iterator.remove();
        Log.i(TAG, "ignore unused resources %s", res);
    }
}
Log.i(TAG, "unused resources count:%d", unusedResources.size());

String outputApk = inputFile.getParentFile().getAbsolutePath() + "/" + inputFile.getName().substring(0, inputFile.getName().indexOf('.')) + "_shrinked.apk";

File outputFile = new File(outputApk);
if (outputFile.exists()) {
    Log.w(TAG, "output apk file %s is already exists! It will be deleted anyway!", outputApk);
    outputFile.delete();
    outputFile.createNewFile();
}

ZipFile zipInputFile = new ZipFile(inputFile);

zipOutputStream = new ZipOutputStream(new FileOutputStream(outputFile));

Map<String, Integer> resourceMap = new HashMap();
Map<String, Pair<String, Integer>[]> styleableMap = new HashMap();
File resTxtFile = new File(rTxtFile);
readResourceTxtFile(resTxtFile, resourceMap, styleableMap);

Map<String, Integer> removeResources = new HashMap<>();
for (String resName : unusedResources) {
    // 这里的ignoreResource判断都是false，因为前面的操作已经将所有需要过滤的都过滤掉了
    if (!ignoreResource(resName)) {
        removeResources.put(resName, resourceMap.remove(resName));
    }
}

for (ZipEntry zipEntry : zipInputFile.entries()) {
    if (zipEntry.name.startsWith("res/")) {
        // 第一步，操作资源文件
        String resourceName = entryToResouceName(zipEntry.name);
        if (!Util.isNullOrNil(resourceName)) {
            if (removeResources.containsKey(resourceName)) {
                Log.i(TAG, "remove unused resource %s", resourceName);
                continue;
            } else {
                addZipEntry(zipOutputStream, zipEntry, zipInputFile);
            }
        } else {
            addZipEntry(zipOutputStream, zipEntry, zipInputFile);
        }
    } else {
        if (needSign && zipEntry.name.startsWith("META-INF/")) {
            // 第二步，META-INF签名文件
            continue;
        } else {
            if (shrinkArsc && zipEntry.name.equalsIgnoreCase("resources.arsc") && unusedResources.size() > 0) {
                // 第三步，处理resources.arsc文件
                File srcArscFile = new File(inputFile.getParentFile().getAbsolutePath() + "/resources.arsc");
                File destArscFile = new File(inputFile.getParentFile().getAbsolutePath() + "/resources_shrinked.arsc");
                if (srcArscFile.exists()) {
                    srcArscFile.delete();
                    srcArscFile.createNewFile();
                }
                unzipEntry(zipInputFile, zipEntry, srcArscFile);

                ArscReader reader = new ArscReader(srcArscFile.getAbsolutePath());
                ResTable resTable = reader.readResourceTable();
                for (String resName : removeResources.keySet()) {
                    ArscUtil.removeResource(resTable, removeResources.get(resName), resName);
                }
                ArscWriter writer = new ArscWriter(destArscFile.getAbsolutePath());
                writer.writeResTable(resTable);
                Log.i(TAG, "shrink resources.arsc size %f KB", (srcArscFile.length() - destArscFile.length()) / 1024.0);
                addZipEntry(zipOutputStream, zipEntry, destArscFile);
            } else {
                addZipEntry(zipOutputStream, zipEntry, zipInputFile);
            }
        }
    }
}

Log.i(TAG, "shrink apk size %f KB", (inputFile.length() - outputFile.length()) / 1024.0);
if (needSign) {
    Log.i(TAG, "resign apk...");
    ProcessBuilder processBuilder = new ProcessBuilder();
    processBuilder.command(apksigner, "sign", "-v",
            "--ks", signingConfig.storeFile.getAbsolutePath(),
            "--ks-pass", "pass:" + signingConfig.storePassword,
            "--key-pass", "pass:" + signingConfig.keyPassword,
            "--ks-key-alias", signingConfig.keyAlias,
            outputFile.getAbsolutePath());
    //Log.i(TAG, "%s", processBuilder.command());
    Process process = processBuilder.start();
    process.waitFor();
    if (process.exitValue() != 0) {
        throw new GradleException(process.getErrorStream().text);
    }
}
String backApk = inputFile.getParentFile().getAbsolutePath() + "/" + inputFile.getName().substring(0, inputFile.getName().indexOf('.')) + "_back.apk";
inputFile.renameTo(new File(backApk));
outputFile.renameTo(new File(originalApk));

//modify R.txt to delete the removed resources
if (!removeResources.isEmpty()) {
    Iterator<String> styleableItera =  styleableMap.keySet().iterator();
    while (styleableItera.hasNext()) {
        String styleable = styleableItera.next();
        Pair<String, Integer>[] attrs = styleableMap.get(styleable);
        int i = 0;
        for (i = 0; i < attrs.length; i++) {
            if (!removeResources.containsValue(attrs[i].right)) {
                break
            }
        }
        if (attrs.length > 0 && i == attrs.length) {
            Log.i(TAG, "removed styleable " + styleable);
            styleableItera.remove();
        }
    }
    //Log.d(TAG, "styleable %s", styleableMap.keySet().size());
    String newResTxtFile = resTxtFile.getParentFile().getAbsolutePath() + "/" + resTxtFile.getName().substring(0, resTxtFile.getName().indexOf('.')) + "_shrinked.txt";
    shrinkResourceTxtFile(newResTxtFile, resourceMap, styleableMap);

    //Other plugins such as "Tinker" may depend on the R.txt file, so we should not modify R.txt directly .
    //new File(newResTxtFile).renameTo(resTxtFile);
}