Matrix v2.0.2

matrix/matrix-android/matrix-gradle-plugin/build.gradle

@@ -5,8 +5,8 @@ dependencies {
     implementation fileTree(include: ['*.jar'], dir: 'libs')
     implementation gradleApi()
     implementation project(':matrix-commons')
-    implementation group: 'org.ow2.asm', name: 'asm', version: '5.1'
-    implementation group: 'org.ow2.asm', name: 'asm-commons', version: '5.1'
+    implementation group: 'org.ow2.asm', name: 'asm', version: '7.0'
+    implementation group: 'org.ow2.asm', name: 'asm-commons', version: '7.0'
     implementation 'com.android.tools.build:gradle:4.0.0'
     implementation project(':matrix-arscutil')
     implementation "org.jetbrains.kotlin:kotlin-stdlib:${gradle.KOTLIN_VERSION}"

matrix/matrix-android/matrix-gradle-plugin/src/main/java/com/tencent/matrix/trace/MethodTracer.java

@@ -27,6 +27,7 @@
 import org.objectweb.asm.MethodVisitor;
 import org.objectweb.asm.Opcodes;
 import org.objectweb.asm.commons.AdviceAdapter;
+import org.objectweb.asm.util.CheckClassAdapter;
 
 import java.io.ByteArrayInputStream;
 import java.io.File;
@@ -67,6 +68,8 @@ public class MethodTracer {
     private final ExecutorService executor;
     private MappingCollector mappingCollector;
 
+    private volatile boolean traceError = false;
+
     public MethodTracer(ExecutorService executor, MappingCollector mappingCollector, Configuration config, ConcurrentHashMap<String, TraceMethod> collectedMap, ConcurrentHashMap<String, String> collectedClassExtendMap) {
         this.configuration = config;
         this.mappingCollector = mappingCollector;
@@ -75,44 +78,46 @@ public MethodTracer(ExecutorService executor, MappingCollector mappingCollector,
         this.collectedMethodMap = collectedMap;
     }
 
-
-    public void trace(Map<File, File> srcFolderList, Map<File, File> dependencyJarList) throws ExecutionException, InterruptedException {
+    public void trace(Map<File, File> srcFolderList, Map<File, File> dependencyJarList, ClassLoader classLoader) throws ExecutionException, InterruptedException {
         List<Future> futures = new LinkedList<>();
-        traceMethodFromSrc(srcFolderList, futures);
-        traceMethodFromJar(dependencyJarList, futures);
+        traceMethodFromSrc(srcFolderList, futures, classLoader);
+        traceMethodFromJar(dependencyJarList, futures, classLoader);
         for (Future future : futures) {
             future.get();
         }
+        if (traceError) {
+            throw new IllegalArgumentException("something wrong with trace, see detail log before");
+        }
         futures.clear();
     }
 
-    private void traceMethodFromSrc(Map<File, File> srcMap, List<Future> futures) {
+    private void traceMethodFromSrc(Map<File, File> srcMap, List<Future> futures, final ClassLoader classLoader) {
         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());
+                        innerTraceMethodFromSrc(entry.getKey(), entry.getValue(), classLoader);
                     }
                 }));
             }
         }
     }
 
-    private void traceMethodFromJar(Map<File, File> dependencyMap, List<Future> futures) {
+    private void traceMethodFromJar(Map<File, File> dependencyMap, List<Future> futures, final ClassLoader classLoader) {
         if (null != dependencyMap) {
             for (Map.Entry<File, File> entry : dependencyMap.entrySet()) {
                 futures.add(executor.submit(new Runnable() {
                     @Override
                     public void run() {
-                        innerTraceMethodFromJar(entry.getKey(), entry.getValue());
+                        innerTraceMethodFromJar(entry.getKey(), entry.getValue(), classLoader);
                     }
                 }));
             }
         }
     }
 
-    private void innerTraceMethodFromSrc(File input, File output) {
+    private void innerTraceMethodFromSrc(File input, File output, ClassLoader classLoader) {
 
         ArrayList<File> classFileList = new ArrayList<>();
         if (input.isDirectory()) {
@@ -133,19 +138,32 @@ private void innerTraceMethodFromSrc(File input, File output) {
                 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);
+                    ClassWriter classWriter = new TraceClassWriter(ClassWriter.COMPUTE_FRAMES, classLoader);
+                    ClassVisitor classVisitor = new TraceClassAdapter(Opcodes.ASM6, classWriter);
                     classReader.accept(classVisitor, ClassReader.EXPAND_FRAMES);
                     is.close();
 
+                    byte[] data = classWriter.toByteArray();
+
+                    try {
+                        ClassReader cr = new ClassReader(data);
+                        ClassWriter cw = new ClassWriter(0);
+                        ClassVisitor check = new CheckClassAdapter(cw);
+                        cr.accept(check, ClassReader.EXPAND_FRAMES);
+                    } catch (Throwable e) {
+                        System.err.println("trace output ERROR : " + e.getMessage() + ", " + classFile);
+                        traceError = true;
+                    }
+
                     if (output.isDirectory()) {
                         os = new FileOutputStream(changedFileOutput);
                     } else {
                         os = new FileOutputStream(output);
                     }
-                    os.write(classWriter.toByteArray());
+                    os.write(data);
                     os.close();
                 } else {
                     FileUtil.copyFileUsingStream(classFile, changedFileOutput);
@@ -168,7 +186,7 @@ private void innerTraceMethodFromSrc(File input, File output) {
         }
     }
 
-    private void innerTraceMethodFromJar(File input, File output) {
+    private void innerTraceMethodFromJar(File input, File output, final ClassLoader classLoader) {
         ZipOutputStream zipOutputStream = null;
         ZipFile zipFile = null;
         try {
@@ -179,12 +197,25 @@ private void innerTraceMethodFromJar(File input, File output) {
                 ZipEntry zipEntry = enumeration.nextElement();
                 String zipEntryName = zipEntry.getName();
                 if (MethodCollector.isNeedTraceFile(zipEntryName)) {
+
                     InputStream inputStream = zipFile.getInputStream(zipEntry);
                     ClassReader classReader = new ClassReader(inputStream);
-                    ClassWriter classWriter = new ClassWriter(ClassWriter.COMPUTE_MAXS);
-                    ClassVisitor classVisitor = new TraceClassAdapter(Opcodes.ASM5, classWriter);
+                    ClassWriter classWriter = new TraceClassWriter(ClassWriter.COMPUTE_FRAMES, classLoader);
+                    ClassVisitor classVisitor = new TraceClassAdapter(Opcodes.ASM6, classWriter);
                     classReader.accept(classVisitor, ClassReader.EXPAND_FRAMES);
                     byte[] data = classWriter.toByteArray();
+//
+                    try {
+                        ClassReader r = new ClassReader(data);
+                        ClassWriter w = new ClassWriter(0);
+                        ClassVisitor v = new CheckClassAdapter(w);
+                        r.accept(v, ClassReader.EXPAND_FRAMES);
+                    } catch (Throwable e) {
+                        System.err.println("trace jar output ERROR: " + e.getMessage() + ", "+ zipEntryName);
+//                        e.printStackTrace();
+                        traceError = true;
+                    }
+
                     InputStream byteArrayInputStream = new ByteArrayInputStream(data);
                     ZipEntry newZipEntry = new ZipEntry(zipEntryName);
                     FileUtil.addZipEntry(zipOutputStream, newZipEntry, byteArrayInputStream);

matrix/matrix-android/matrix-gradle-plugin/src/main/java/com/tencent/matrix/trace/TraceClassLoader.java

@@ -0,0 +1,70 @@
+package com.tencent.matrix.trace;
+
+import com.android.build.gradle.AppExtension;
+import com.android.build.gradle.BaseExtension;
+import com.android.build.gradle.LibraryExtension;
+import com.google.common.collect.ImmutableList;
+
+import org.gradle.api.Project;
+
+import java.io.File;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.Collection;
+
+/**
+ * Created by habbyge on 2019/4/24.
+ */
+public class TraceClassLoader {
+
+    public static URLClassLoader getClassLoader(Project project, Collection<File> inputFiles)
+            throws MalformedURLException {
+
+        ImmutableList.Builder<URL> urls = new ImmutableList.Builder<>();
+        File androidJar = getAndroidJar(project);
+        if (androidJar != null) {
+            urls.add(androidJar.toURI().toURL());
+        }
+
+        for (File inputFile : inputFiles) {
+            urls.add(inputFile.toURI().toURL());
+        }
+
+//        for (TransformInput inputs : Iterables.concat(invocation.getInputs(), invocation.getReferencedInputs())) {
+//            for (DirectoryInput directoryInput : inputs.getDirectoryInputs()) {
+//                if (directoryInput.getFile().isDirectory()) {
+//                    urls.add(directoryInput.getFile().toURI().toURL());
+//                }
+//            }
+//            for (JarInput jarInput : inputs.getJarInputs()) {
+//                if (jarInput.getFile().isFile()) {
+//                    urls.add(jarInput.getFile().toURI().toURL());
+//                }
+//            }
+//        }
+
+        ImmutableList<URL> urlImmutableList = urls.build();
+        URL[] classLoaderUrls = urlImmutableList.toArray(new URL[urlImmutableList.size()]);
+        return new URLClassLoader(classLoaderUrls);
+    }
+
+    private static File getAndroidJar(Project project) {
+        BaseExtension extension = null;
+        if (project.getPlugins().hasPlugin("com.android.application")) {
+            extension = project.getExtensions().findByType(AppExtension.class);
+        } else if (project.getPlugins().hasPlugin("com.android.library")) {
+            extension = project.getExtensions().findByType(LibraryExtension.class);
+        }
+        if (extension == null) {
+            return null;
+        }
+
+        String sdkDirectory = extension.getSdkDirectory().getAbsolutePath();
+        String compileSdkVersion = extension.getCompileSdkVersion();
+        sdkDirectory = sdkDirectory + File.separator + "platforms" + File.separator;
+        String androidJarPath = sdkDirectory + compileSdkVersion + File.separator + "android.jar";
+        File androidJar = new File(androidJarPath);
+        return androidJar.exists() ? androidJar : null;
+    }
+}

matrix/matrix-android/matrix-gradle-plugin/src/main/java/com/tencent/matrix/trace/TraceClassWriter.java

@@ -0,0 +1,152 @@
+package com.tencent.matrix.trace;
+
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassWriter;
+
+/**
+ * Created by habbyge on 2019/4/25.
+ *
+ * fix:
+ * java.lang.TypeNotPresentException: Type android/content/res/TypedArray not present
+ *     at org.objectweb.asm.ClassWriter.getCommonSuperClass(ClassWriter.java:1025)
+ *     at org.objectweb.asm.SymbolTable.addMergedType(SymbolTable.java:1202)
+ *     at org.objectweb.asm.Frame.merge(Frame.java:1299)
+ *     at org.objectweb.asm.Frame.merge(Frame.java:1197)
+ *     at org.objectweb.asm.MethodWriter.computeAllFrames(MethodWriter.java:1610)
+ *     at org.objectweb.asm.MethodWriter.visitMaxs(MethodWriter.java:1546)
+ *     at org.objectweb.asm.tree.MethodNode.accept(MethodNode.java:769)
+ *     at org.objectweb.asm.util.CheckMethodAdapter$1.visitEnd(CheckMethodAdapter.java:465)
+ *     at org.objectweb.asm.MethodVisitor.visitEnd(MethodVisitor.java:783)
+ *     at org.objectweb.asm.util.CheckMethodAdapter.visitEnd(CheckMethodAdapter.java:1036)
+ *     at org.objectweb.asm.ClassReader.readMethod(ClassReader.java:1495)
+ *     at org.objectweb.asm.ClassReader.accept(ClassReader.java:721)
+ *
+ */
+class TraceClassWriter extends ClassWriter {
+    private ClassLoader mClassLoader;
+    public TraceClassWriter(int flags, ClassLoader classLoader) {
+        super(flags);
+        mClassLoader = classLoader;
+    }
+
+    public TraceClassWriter(ClassReader classReader, int flags, ClassLoader classLoader) {
+        super(classReader, flags);
+        mClassLoader = classLoader;
+    }
+
+    @Override
+    protected String getCommonSuperClass(String type1, String type2) {
+        try {
+            return super.getCommonSuperClass(type1, type2);
+        } catch (Exception e) {
+            try {
+                return getCommonSuperClassV1(type1, type2);
+            } catch (Exception e1) {
+                try {
+                    return getCommonSuperClassV2(type1, type2);
+                } catch (Exception e2) {
+                    return getCommonSuperClassV3(type1, type2);
+                }
+            }
+        }
+    }
+
+    private String getCommonSuperClassV1(String type1, String type2) {
+        ClassLoader curClassLoader = getClass().getClassLoader();
+
+        Class clazz1, clazz2;
+        try {
+            clazz1 = Class.forName(type1.replace('/', '.'), false, mClassLoader);
+            clazz2 = Class.forName(type2.replace('/', '.'), false, mClassLoader);
+        } catch (Exception e) {
+            /*throw new RuntimeException(e.toString());*/
+            /*e.printStackTrace();*/
+            return "java/lang/Object";
+        } catch (LinkageError error) {
+            return "java/lang/Object";
+        }
+        //noinspection unchecked
+        if (clazz1.isAssignableFrom(clazz2)) {
+            return type1;
+        }
+        //noinspection unchecked
+        if (clazz2.isAssignableFrom(clazz1)) {
+            return type2;
+        }
+        if (clazz1.isInterface() || clazz2.isInterface()) {
+            return "java/lang/Object";
+        } else {
+            //noinspection unchecked
+            do {
+                clazz1 = clazz1.getSuperclass();
+            } while (!clazz1.isAssignableFrom(clazz2));
+            return clazz1.getName().replace('.', '/');
+        }
+    }
+
+    private String getCommonSuperClassV2(String type1, String type2) {
+        ClassLoader curClassLoader = getClass().getClassLoader();
+
+        Class clazz1, clazz2;
+        try {
+            clazz1 = Class.forName(type1.replace('/', '.'), false, curClassLoader);
+            clazz2 = Class.forName(type2.replace('/', '.'), false, mClassLoader);
+        } catch (Exception e) {
+            /*throw new RuntimeException(e.toString());*/
+            /*e.printStackTrace();*/
+            return "java/lang/Object";
+        } catch (LinkageError error) {
+            return "java/lang/Object";
+        }
+        //noinspection unchecked
+        if (clazz1.isAssignableFrom(clazz2)) {
+            return type1;
+        }
+        //noinspection unchecked
+        if (clazz2.isAssignableFrom(clazz1)) {
+            return type2;
+        }
+        if (clazz1.isInterface() || clazz2.isInterface()) {
+            return "java/lang/Object";
+        } else {
+            //noinspection unchecked
+            do {
+                clazz1 = clazz1.getSuperclass();
+            } while (!clazz1.isAssignableFrom(clazz2));
+            return clazz1.getName().replace('.', '/');
+        }
+    }
+
+    private String getCommonSuperClassV3(String type1, String type2) {
+        ClassLoader curClassLoader = getClass().getClassLoader();
+
+        Class clazz1, clazz2;
+        try {
+            clazz1 = Class.forName(type1.replace('/', '.'), false, mClassLoader);
+            clazz2 = Class.forName(type2.replace('/', '.'), false, curClassLoader);
+        } catch (Exception e) {
+            /*e.printStackTrace();*/
+            /*throw new RuntimeException(e.toString());*/
+            return "java/lang/Object";
+        } catch (LinkageError error) {
+            return "java/lang/Object";
+        }
+        //noinspection unchecked
+        if (clazz1.isAssignableFrom(clazz2)) {
+            return type1;
+        }
+        //noinspection unchecked
+        if (clazz2.isAssignableFrom(clazz1)) {
+            return type2;
+        }
+        if (clazz1.isInterface() || clazz2.isInterface()) {
+            return "java/lang/Object";
+        } else {
+            //noinspection unchecked
+            do {
+                clazz1 = clazz1.getSuperclass();
+            } while (!clazz1.isAssignableFrom(clazz2));
+            return clazz1.getName().replace('.', '/');
+        }
+    }
+}

matrix/matrix-android/matrix-gradle-plugin/src/main/kotlin/com/tencent/matrix/plugin/task/MatrixTraceTask.kt

@@ -107,7 +107,8 @@ abstract class MatrixTraceTask : DefaultTask() {
                     methodMapFilePath = methodMapFileOutput.asFile.get().absolutePath,
                     baseMethodMapPath = baseMethodMapFile.asFile.orNull?.absolutePath,
                     blockListFilePath = blockListFile.asFile.orNull?.absolutePath,
-                    mappingDir = mappingDir.get()
+                    mappingDir = mappingDir.get(),
+                    project = project
             ).doTransform(
                     classInputs = classInputs.files,
                     changedFiles = changedFiles,