org.jf.dexlib2.dexbacked.DexBackedMethod Java Examples

public void analyze() {
    for (DexFile dexFile : dexFiles) {
        for (DexMethod dexMethod : dexFile.getMethodDescriptorToMethod().values()) {
            if (dexMethod.getCyclomaticComplexity() >= 0) {
                continue;
            }

            DexBackedMethod method = dexMethod.getMethod();
            DexBackedMethodImplementation implementation = method.getImplementation();
            if (implementation != null) {
                int complexity = calculateComplexity(implementation, dexFiles, new HashSet<>());
                dexMethod.setCyclomaticComplexity(complexity);
            }
        }

    }

}
 

private static boolean compare(DexBackedMethod dexBackedMethod, DexBackedMethod sDexBackedMethod) {
    if (dexBackedMethod == null || sDexBackedMethod == null || dexBackedMethod.getName() == null || sDexBackedMethod.getName() == null) {
        return false;
    }
    if (dexBackedMethod.getName().equals(sDexBackedMethod.getName())) {
        List<String> parameters = dexBackedMethod.getParameterTypes();
        List<String> sParameters = sDexBackedMethod.getParameterTypes();
        if (parameters.size() != sParameters.size()) {
            return false;
        }
        for (String param : parameters) {
            if (!sParameters.contains(param)) {
                return false;
            }
        }
        return true;
    }
    return false;
}
 

@Override
public boolean filterMethod(MethodDiffInfo methodDiffInfo) throws PatchException {
    DexBackedMethod dexBackedMethod = methodDiffInfo.getBackedMethod();
    if (dexBackedMethod.getName().equals("<clinit>") || dexBackedMethod.getName().contains("ajc$preClinit")||dexBackedMethod.getName().equals("<init>")||dexBackedMethod.getName().contains("access$")) {
        return true;
    }

    if (methodDiffInfo.getType().equals(DiffType.REMOVE)) {
        return true;
    } else if (methodDiffInfo.getType().equals(DiffType.ADD)){
        throw new PatchException("can't add method:" + dexBackedMethod.getName() + " in class:" + dexBackedMethod.getDefiningClass());
    }

    if (dexBackedMethod.getParameters().size() > 8) {
        throw new PatchException("can't patch method:" + dexBackedMethod.getName() + "has Parameters above 8 in class:"+dexBackedMethod.getDefiningClass());
    }
    if (dexBackedMethod.getParameterTypes().contains("J") || dexBackedMethod.getParameterTypes().contains("D") || dexBackedMethod.getParameterTypes().contains("F")) {
       throw new PatchException("can't patch method:" + dexBackedMethod.getName() + "has ParameterType long,double or float in class:"+dexBackedMethod.getDefiningClass());
    }
    return false;
}
 

DexMethod(DexBackedMethod method, boolean shortMethodSignatures) {
    this.method = method;
    this.shortMethodSignatures = shortMethodSignatures;

    size = method.getSize();
    accessFlags = method.getAccessFlags();
    annotationCount = method.getAnnotations().size();
    frameworkApiCounts = new TObjectIntHashMap<>();
    frameworkFieldReferenceCounts = new TObjectIntHashMap<>();
    opCounts = new TIntIntHashMap();
    stringReferenceCounts = new TObjectIntHashMap<>();
    if (method.getImplementation() != null) {
        analyze(method.getImplementation());
    }
}
 

public static void getMethodAnnotaionPrepareClasses(DexDiffInfo dexDiffInfo, Set<String> prepareclasses){

        for (DexBackedMethod method:dexDiffInfo.getModifiedMethods()){
            Set<? extends Annotation>annotations = method.getAnnotations();
            if (annotations == null){
                continue;
            }
            for (Annotation annotation:annotations){
                String type = annotation.getType();
                if (type!= null&&type.startsWith("L")&&type.endsWith(";")){
                    prepareclasses.add(type.substring(1, type.length() - 1).replace('/', '.'));
                    System.out.println("prepare class: " + type);
                }
                Set<? extends AnnotationElement> elements = annotation.getElements();
                for (AnnotationElement dexBackedAnnotationElement:elements){
                    if (dexBackedAnnotationElement.getValue() instanceof DexBackedArrayEncodedValue){
                        List<? extends EncodedValue> values = ((DexBackedArrayEncodedValue) dexBackedAnnotationElement.getValue()).getValue();
                        for (EncodedValue encodedValue:values) {
                            if (encodedValue instanceof TypeEncodedValue) {
                                prepareclasses.add(((TypeEncodedValue) encodedValue).getValue().substring(1, ((TypeEncodedValue) encodedValue).getValue().length() - 1).replace('/', '.'));
                                System.out.println("prepare class: " + ((TypeEncodedValue) encodedValue).getValue());
                            }
                        }

                    }else if (dexBackedAnnotationElement.getValue() instanceof DexBackedTypeEncodedValue){
                        String value = ((DexBackedTypeEncodedValue) dexBackedAnnotationElement.getValue()).getValue();
                        prepareclasses.add(value.substring(1, value.length() - 1).replace('/', '.'));
                        System.out.println("prepare class: " + value);
                    }
                }
            }
        }

    }
 

public void addModifiedMethods(DexBackedMethod method) throws PatchException {
    System.out.println("add modified Method:" + method.getReturnType()
            + "  " + method.getName() + "("
            + Formater.formatStringList(method.getParameterTypes())
            + ")  in Class:" + method.getDefiningClass());
    this.modifiedMethods.add(method);

    if (!modifiedClasses.contains(method.classDef)) {
        modifiedClasses.add(method.classDef);
        String className = method.classDef.getType();
        addManifestModifiedClass(className);
    }
}
 

public DexBackedMethod getMethod() {
    return method;
}
 

private static Set<String> buildPrepareClass(File smaliDir, List<File> newFiles,
                                                 DexDiffInfo info) throws PatchException {
        Set<DexBackedClassDef> classes = Sets.newHashSet();
        classes = SmaliDiffUtils.scanClasses(smaliDir, newFiles);
        ArrayList<String> methods = new ArrayList<String>();
        {
            Set<DexBackedMethod> tempSet = info.getModifiedMethods();
            for (DexBackedMethod methodRef : tempSet) {
                String template = methodRef.getDefiningClass() + "->" + methodRef.getName();
                methods.add(template);
                System.out.println("template: " + template);
                if (superClasses.containsKey(methodRef.getDefiningClass())) {
                    ArrayList<String> derivedClasses = superClasses.get(methodRef.getDefiningClass());
                    for (int i = 0; i < derivedClasses.size(); i++) {
                        template = derivedClasses.get(i) + "->" + methodRef.getName();
                        System.out.println("template: " + template);
                        methods.add(template);
                    }
                }
            }
        }

        Set<String> prepareClasses = new HashSet<String>();
        try {
            final ClassFileNameHandler inFileNameHandler = new ClassFileNameHandler(smaliDir, ".smali");
            for (DexBackedClassDef classDef : classes) {
                currentClassType = null;
                String className = TypeGenUtil.newType(classDef.getType());
                // baksmali.disassembleClass(classDef, outFileNameHandler, options);
                File smaliFile = inFileNameHandler.getUniqueFilenameForClass(className);
                if (!smaliFile.exists()){
                    continue;
                }
                //增加class注解到prepare
                getClassAnnotaionPrepareClasses(classDef,prepareClasses,info);

                BufferedReader br = new BufferedReader(new FileReader(smaliFile));
                String data = br.readLine();// 一次读入一行，直到读入null为文件结束
                while (data != null) {
                    boolean find = false;
                    for (String m : methods) {
                        if (data.contains(m)) {
                            find = true;
                            break;
                        }
                    }
                    if (find) {
                        prepareClasses.add(className.substring(1, className.length() - 1).replace('/', '.'));
                        System.out.println("prepare class: " + className);
                        break;
                    }
                    data = br.readLine(); // 接着读下一行
                }
                br.close();

            }
        } catch (Exception e) {
            throw new PatchException(e);
        }
        for (DexBackedMethod method:info.getModifiedMethods()) {
            prepareClasses.add(method.getDefiningClass().substring(1, method.getDefiningClass().length() - 1).replace("/", "."));
        }
        //增加modify的anatation到prepare
//        getMethodAnnotaionPrepareClasses(info,prepareClasses);
        return prepareClasses;
    }
 

public DexBackedMethod getBackedMethod() {
    return backedMethod;
}
 

public void setBackedMethod(DexBackedMethod backedMethod) {
    this.backedMethod = backedMethod;
}
 

public Set<DexBackedMethod> getModifiedMethods() {
    return modifiedMethods;
}
 

public Set<DexBackedMethod> getAddedMethods() {
    return addedMethods;
}