org.jf.dexlib2.iface.ClassDef Java Examples

public static ImmutableClassDef of(ClassDef classDef) {
    if (classDef instanceof ImmutableClassDef) {
        return (ImmutableClassDef)classDef;
    }
    return new ImmutableClassDef(
            classDef.getType(),
            classDef.getAccessFlags(),
            classDef.getSuperclass(),
            classDef.getInterfaces(),
            classDef.getSourceFile(),
            classDef.getAnnotations(),
            classDef.getStaticFields(),
            classDef.getInstanceFields(),
            classDef.getDirectMethods(),
            classDef.getVirtualMethods());
}
 

/**
 * 生成解析成smali代码的选项
 *
 * @return
 */
private static BaksmaliOptions createBaksmaliOptions(ClassDef classDef) {
    BaksmaliOptions options = new BaksmaliOptions();
    options.deodex = false;
    options.parameterRegisters = false;
    options.localsDirective = true;
    options.sequentialLabels = true;
    options.debugInfo = false;
    options.codeOffsets = false;
    options.accessorComments = false;
    options.registerInfo = 0;// 128
    options.inlineResolver = null;
    options.apiLevel = DEFAULT_API_LEVEL;
    List<ClassDef> classDefs = Lists.newArrayList();
    classDefs.add(classDef);
    options.syntheticAccessorResolver = new SyntheticAccessorResolver(Opcodes.getDefault(),classDefs);
    return options;
}
 

private ClassDetail translateClassDef(ClassInfo ci, ClassDef classDef, IdentityHashMap<MethodInfo, MethodImplementation> collector) {
    ClassDetail.Builder builder = new ClassDetail.Builder();
    if (classDef.getSuperclass() == null) {
        builder.setBaseType(null); // for java.lang.Object
    } else {
        builder.setBaseType(Dalvik.findOrCreateClass(ci.scope, classDef.getSuperclass()));
    }
    builder.setInterfaces(findOrCreateClasses(ci.scope, classDef.getInterfaces()));
    builder.setAccessFlags(translateAccessFlags(classDef.getAccessFlags()));
    builder.setAllMethods(translateMethods(ci, classDef.getMethods(), collector));
    builder.setStaticFields(translateFields(ci.scope, classDef.getStaticFields()));
    HashMap<String, ClassInfo> fields = translateFields(ci.scope, classDef.getInstanceFields());
    // TODO: do we need this?
    if (ci.isInnerClass()) {
        fields.put("this$0", ci.getOuterClass());
    }
    builder.setFields(fields);
    builder.setIsFrameworkClass(isFramework);
    return builder.build();
}
 

@Override
public Set<ClassDef> createModifyClasses() throws IOException, PatchException {
    dexDiffer.setTpatch(false);
    Set<ClassDef>mClasses =  super.createModifyClasses();
    if (hotClassList == null || hotClassList.size() == 0){
        return mClasses;
    }
    hotClassDefs = new HashSet<>();
    Iterator<ClassDef>iterator = mClasses.iterator();
    while (iterator.hasNext()) {
        ClassDef classDef = iterator.next();
        if (hotClassList.contains(classDef.getType()) || hotClassList.contains(SmaliUtils.getDalvikClassName(classDef.getType()))) {
                hotClassDefs.add(classDef);
                iterator.remove();
            }
    }
    return mClasses;

}
 

public PatchDexTool(List<File> baseDexFiles, List<File> newDexFiles, int apiLevel, Map<String,ClassDef> map,boolean mainBundle) {
    this.baseDexFiles = baseDexFiles;
    this.newDexFiles = newDexFiles;
    this.apiLevel = apiLevel;
    this.mainBundle = mainBundle;
    assert (null != baseDexFiles && baseDexFiles.size() > 0);
    assert (null != newDexFiles && newDexFiles.size() > 0);
    this.dexDiffer = new DexDiffer(baseDexFiles, newDexFiles, apiLevel);
    if (map == null) {
        dexDiffer.setLastBundleClassMap(lastBundleClassMap);
    }else {
        dexDiffer.setLastBundleClassMap(map);
    }


}
 

public static BaksmaliOptions getBuildOption(Iterable<? extends ClassDef> collection, int apiLevel) {
    BaksmaliOptions options = new BaksmaliOptions();

    options.deodex = false;
    options.parameterRegisters = false;
    options.localsDirective = true;
    options.sequentialLabels = true;
    options.debugInfo = true;
    options.codeOffsets = false;
    options.accessorComments = false;
    options.registerInfo = 0;// 128
    options.inlineResolver = null;
    options.apiLevel = apiLevel;
    if (!options.accessorComments) {
        options.syntheticAccessorResolver = new SyntheticAccessorResolver(Opcodes.getDefault(),collection);
    }

    return options;
}
 

public static ImmutableClassDef of(ClassDef classDef) {
    if (classDef instanceof ImmutableClassDef) {
        return (ImmutableClassDef)classDef;
    }
    return new ImmutableClassDef(
            classDef.getType(),
            classDef.getAccessFlags(),
            classDef.getSuperclass(),
            classDef.getInterfaces(),
            classDef.getSourceFile(),
            classDef.getAnnotations(),
            classDef.getStaticFields(),
            classDef.getInstanceFields(),
            classDef.getDirectMethods(),
            classDef.getVirtualMethods());
}
 

private void fillFromDex(File file, ClassNode rootNode) {
    try {
        DexFile dxFile = DexlibLoader.loadDexFile(file);

        Set<? extends ClassDef> classSet = dxFile.getClasses();
        for (ClassDef o : classSet) {
            int methodCount = 0;
            for (Method method : o.getMethods()) {
                methodCount++;
            }

            String translatedClassName = o.getType().replaceAll("\\/", "\\.").substring(1, o.getType().length() - 1);
            ClassInfo classInfo = new ClassInfo(translatedClassName, methodCount);
            rootNode.add(classInfo);
        }

    } catch (Exception ex) {
        System.err.println("Error parsing Dexfile: " + file.getName() + ": " + ex.getMessage());
        ex.printStackTrace(System.err);
    }
}
 

public static ImmutableClassDef of(ClassDef classDef) {
    if (classDef instanceof ImmutableClassDef) {
        return (ImmutableClassDef)classDef;
    }
    return new ImmutableClassDef(
            classDef.getType(),
            classDef.getAccessFlags(),
            classDef.getSuperclass(),
            classDef.getInterfaces(),
            classDef.getSourceFile(),
            classDef.getAnnotations(),
            classDef.getStaticFields(),
            classDef.getInstanceFields(),
            classDef.getDirectMethods(),
            classDef.getVirtualMethods());
}
 

public static void writeTo(@Nonnull String path, @Nonnull org.jf.dexlib2.iface.DexFile input) throws IOException {
    DexPool dexPool = makeDexPool();
    for (ClassDef classDef: input.getClasses()) {
        ((ClassPool)dexPool.classSection).intern(classDef);
    }
    dexPool.writeTo(new FileDataStore(new File(path)));
}
 

/**
 * Gets the interfaces directly implemented by this class, or the interfaces they transitively implement.
 *
 * This does not include any interfaces that are only implemented by a superclass
 *
 * @return An iterables of ClassDefs representing the directly or transitively implemented interfaces
 * @throws UnresolvedClassException if interfaces could not be fully resolved
 */
@Nonnull
protected Iterable<ClassDef> getDirectInterfaces() {
    Iterable<ClassDef> directInterfaces =
            FluentIterable.from(getInterfaces().values()).filter(Predicates.notNull());

    if (!interfacesFullyResolved) {
        throw new UnresolvedClassException("Interfaces for class %s not fully resolved", getType());
    }

    return directInterfaces;
}
 

public static void writeTo(@Nonnull String path, @Nonnull org.jf.dexlib2.iface.DexFile input) throws IOException {
    DexPool dexPool = makeDexPool();
    for (ClassDef classDef: input.getClasses()) {
        ((ClassPool)dexPool.classSection).intern(classDef);
    }
    dexPool.writeTo(new FileDataStore(new File(path)));
}
 

/**
 * Gets the interfaces directly implemented by this class, or the interfaces they transitively implement.
 *
 * This does not include any interfaces that are only implemented by a superclass
 *
 * @return An iterables of ClassDefs representing the directly or transitively implemented interfaces
 * @throws UnresolvedClassException if interfaces could not be fully resolved
 */
@Nonnull
protected Iterable<ClassDef> getDirectInterfaces() {
    Iterable<ClassDef> directInterfaces =
            FluentIterable.from(getInterfaces().values()).filter(Predicates.notNull());

    if (!interfacesFullyResolved) {
        throw new UnresolvedClassException("Interfaces for class %s not fully resolved", getType());
    }

    return directInterfaces;
}
 

public ClassDef read(String className,String memberName){
    if (classDefs == null){
        return null;
    }
    for (ClassDef classDef:classDefs){
        if (classDef.getType().equals(className)){
            return classDef;
        }
    }
    return null;
}
 

/**
 * Creates a new ClassPath instance that can load classes from the given dex files
 *
 * @param classPath An iterable of DexFile objects. When loading a class, these dex files will be searched in order
 * @param api API level
 */
public ClassPath(@Nonnull Iterable<DexFile> classPath, int api) {
    // add fallbacks for certain special classes that must be present
    Iterable<DexFile> dexFiles = Iterables.concat(classPath, Lists.newArrayList(getBasicClasses()));

    unknownClass = new UnknownClassProto(this);
    loadedClasses.put(unknownClass.getType(), unknownClass);
    this.api = api;

    loadPrimitiveType("Z");
    loadPrimitiveType("B");
    loadPrimitiveType("S");
    loadPrimitiveType("C");
    loadPrimitiveType("I");
    loadPrimitiveType("J");
    loadPrimitiveType("F");
    loadPrimitiveType("D");
    loadPrimitiveType("L");
    //Logger.log("add the classinfo by classpath");
    for (DexFile dexFile: dexFiles) {
        for (ClassDef classDef: dexFile.getClasses()) {
            ClassDef prev = availableClasses.get(classDef.getType());
            if (prev == null) {
                availableClasses.put(classDef.getType(), classDef);
                //Logger.log("add the calldef "+classDef.getType());
            }
        }
    }
    //Logger.log("end the classinfo by classpath");
}
 

@Nonnull
public ClassDef getClassDef(String type) {
    ClassDef ret = availableClasses.get(type);
    if (ret == null) {
        throw new UnresolvedClassException("Could not resolve class %s", type);
    }
    return ret;
}
 

public static List<String> readClassNamesFromDex(File binaryArchiveFile) throws Exception {
    DexFile dexFile = DexlibLoader.loadDexFile(binaryArchiveFile);
    List<String> result = new ArrayList<>();

    for (ClassDef classDef : dexFile.getClasses()) {
        result.add(classDef.getType().replaceAll("/", ".").
                substring(1, classDef.getType().length() - 1));
    }

    Collections.sort(result);
    return result;
}
 

private static boolean methodNeedsModification(@Nonnull ClassDef classDef, @Nonnull Method method, boolean isAndFix) {

        if (isAndFix) {
            return true;
        } else if (method.getName().equals("<init>")) {
            return true;
        }
        return false;

    }
 

PoolClassDef(@Nonnull ClassDef classDef) {
    this.classDef = classDef;

    interfaces = new TypeListPool.Key<SortedSet<String>>(ImmutableSortedSet.copyOf(classDef.getInterfaces()));
    staticFields = ImmutableSortedSet.copyOf(classDef.getStaticFields());
    instanceFields = ImmutableSortedSet.copyOf(classDef.getInstanceFields());
    directMethods = ImmutableSortedSet.copyOf(
            Iterables.transform(classDef.getDirectMethods(), PoolMethod.TRANSFORM));
    virtualMethods = ImmutableSortedSet.copyOf(
            Iterables.transform(classDef.getVirtualMethods(), PoolMethod.TRANSFORM));
}
 

PoolClassDef(@Nonnull ClassDef classDef) {
    this.classDef = classDef;

    interfaces = new TypeListPool.Key<SortedSet<String>>(ImmutableSortedSet.copyOf(classDef.getInterfaces()));
    staticFields = ImmutableSortedSet.copyOf(classDef.getStaticFields());
    instanceFields = ImmutableSortedSet.copyOf(classDef.getInstanceFields());
    directMethods = ImmutableSortedSet.copyOf(
            Iterables.transform(classDef.getDirectMethods(), PoolMethod.TRANSFORM));
    virtualMethods = ImmutableSortedSet.copyOf(
            Iterables.transform(classDef.getVirtualMethods(), PoolMethod.TRANSFORM));
}
 

public static void writeTo(@Nonnull String path, @Nonnull org.jf.dexlib2.iface.DexFile input) throws IOException {
    DexPool dexPool = makeDexPool();
    for (ClassDef classDef: input.getClasses()) {
        ((ClassPool)dexPool.classSection).intern(classDef);
    }
    dexPool.writeTo(new FileDataStore(new File(path)));
}
 

@Override
public Set<ClassDef> createModifyClasses() throws IOException, PatchException {
    dexDiffer.setTpatch(false);
    dexDiffer.setExludeClasses(excludeClasses);
    dexDiffer.setPatchClasses(patchClasses);
    return super.createModifyClasses();
}
 

public DexDiffInfo createPatchDex(File outDexFolder) throws IOException, RecognitionException, PatchException {
     Set<ClassDef>modifyClasses = createModifyClasses();
        if (modifyClasses.size() > 0) {
            writeDex(outDexFolder,modifyClasses);
            writePatchInfo(outDexFolder);

        }
    return dexDiffInfo;
}
 

private List<ClassDef> sort(Set<ClassDef> classDefs){
    List<ClassDef>lastDexClasses = new ArrayList<>();
    classDefs.forEach(classDef -> {
        if (classDef.getType().equals("Landroid/taobao/atlas/framework/FrameworkProperties;")||classDef.getType().equals("Landroid/taobao/atlas/bundleInfo/AtlasBundleInfoGenerator;")){
            lastDexClasses.add(classDef);
        }
    });
    classDefs.removeAll(lastDexClasses);

    classDefs.forEach(classDef -> lastDexClasses.add(0,classDef));

    return lastDexClasses;
}
 

public MetaObjectDex(ClassDef classDef) {
    super();
    this.classDef = classDef;

    if (this.classDef == null) {
        this.classDef = new EmptyClassDef();
    }
}
 

PoolClassDef(@Nonnull ClassDef classDef) {
    this.classDef = classDef;

    interfaces = new TypeListPool.Key<SortedSet<String>>(ImmutableSortedSet.copyOf(classDef.getInterfaces()));
    staticFields = ImmutableSortedSet.copyOf(classDef.getStaticFields());
    instanceFields = ImmutableSortedSet.copyOf(classDef.getInstanceFields());
    directMethods = ImmutableSortedSet.copyOf(
            Iterables.transform(classDef.getDirectMethods(), PoolMethod.TRANSFORM));
    virtualMethods = ImmutableSortedSet.copyOf(
            Iterables.transform(classDef.getVirtualMethods(), PoolMethod.TRANSFORM));
}
 

public static ClassDef getClassDefByName(String className, DexFile dexFile)
        throws Exception {
    ClassDef result = null;
    String dexName;

    for (ClassDef currentClassDef : dexFile.getClasses()) {
        dexName = currentClassDef.getType();
        if (isMatchFromDex(className, dexName)) {
            result = currentClassDef;
            break;
        }
    }

    return result;
}
 

public ClassDefinition(BaksmaliOptions options, ClassDef classDef) {
    this.options = options;
    this.classDef = classDef;
    this.isScan = false;
    this.fieldsSetInStaticConstructor = findFieldsSetInStaticConstructor();
    this.fullMethod = true;
}
 

/**
 * Creates a new ClassPath instance that can load classes from the given dex files
 *
 * @param classPath An iterable of DexFile objects. When loading a class, these dex files will be searched in order
 * @param api API level
 */
public ClassPath(@Nonnull Iterable<DexFile> classPath, int api) {
    // add fallbacks for certain special classes that must be present
    Iterable<DexFile> dexFiles = Iterables.concat(classPath, Lists.newArrayList(getBasicClasses()));

    unknownClass = new UnknownClassProto(this);
    loadedClasses.put(unknownClass.getType(), unknownClass);
    this.api = api;

    loadPrimitiveType("Z");
    loadPrimitiveType("B");
    loadPrimitiveType("S");
    loadPrimitiveType("C");
    loadPrimitiveType("I");
    loadPrimitiveType("J");
    loadPrimitiveType("F");
    loadPrimitiveType("D");
    loadPrimitiveType("L");
    //Logger.log("add the classinfo by classpath");
    for (DexFile dexFile: dexFiles) {
        for (ClassDef classDef: dexFile.getClasses()) {
            ClassDef prev = availableClasses.get(classDef.getType());
            if (prev == null) {
                availableClasses.put(classDef.getType(), classDef);
                //Logger.log("add the calldef "+classDef.getType());
            }
        }
    }
    //Logger.log("end the classinfo by classpath");
}
 

private static Map<String, ClassDef> getBundleClassDef(File file) throws IOException {
    HashMap<String, ClassDef> classDefMap = new HashMap<String, ClassDef>();
    File[] dexFiles = getDexFiles(file);
    HashSet<ClassDef> classDefs = new HashSet<ClassDef>();
    for (File dexFile : dexFiles) {
        classDefs.addAll(DexFileFactory.loadDexFile(dexFile, Opcodes.getDefault()).getClasses());
    }
    for (ClassDef classDef : classDefs) {
        classDefMap.put(classDef.getType(), classDef);
    }

    return classDefMap;
}