import com.android.dex.ClassDef; //导入依赖的package包/类
/**
 * Reads a class_def_item beginning at {@code in} and writes the index and
 * data.
 */
private void transformClassDef(Dex in, ClassDef classDef, IndexMap indexMap) {
    idsDefsOut.assertFourByteAligned();
    idsDefsOut.writeInt(classDef.getTypeIndex());
    idsDefsOut.writeInt(classDef.getAccessFlags());
    idsDefsOut.writeInt(classDef.getSupertypeIndex());
    idsDefsOut.writeInt(classDef.getInterfacesOffset());

    int sourceFileIndex = indexMap.adjustString(classDef.getSourceFileIndex());
    idsDefsOut.writeInt(sourceFileIndex);

    int annotationsOff = classDef.getAnnotationsOffset();
    idsDefsOut.writeInt(indexMap.adjustAnnotationDirectory(annotationsOff));

    int classDataOff = classDef.getClassDataOffset();
    if (classDataOff == 0) {
        idsDefsOut.writeInt(0);
    } else {
        idsDefsOut.writeInt(classDataOut.getPosition());
        ClassData classData = in.readClassData(classDef);
        transformClassData(in, classData, indexMap);
    }

    int staticValuesOff = classDef.getStaticValuesOffset();
    idsDefsOut.writeInt(indexMap.adjustStaticValues(staticValuesOff));
}
 

import com.android.dex.ClassDef; //导入依赖的package包/类
/**
 * Returns the set of types that can be assigned to {@code typeIndex}.
 */
private Set<Integer> findAssignableTypes(Dex dex, int typeIndex) {
    Set<Integer> assignableTypes = new HashSet<Integer>();
    assignableTypes.add(typeIndex);

    for (ClassDef classDef : dex.classDefs()) {
        if (assignableTypes.contains(classDef.getSupertypeIndex())) {
            assignableTypes.add(classDef.getTypeIndex());
            continue;
        }

        for (int implemented : classDef.getInterfaces()) {
            if (assignableTypes.contains(implemented)) {
                assignableTypes.add(classDef.getTypeIndex());
                break;
            }
        }
    }

    return assignableTypes;
}
 

import com.android.dex.ClassDef; //导入依赖的package包/类
private void loadStaticValues(ClassDef cls, List<FieldNode> staticFields) throws DecodeException {
	for (FieldNode f : staticFields) {
		if (f.getAccessFlags().isFinal()) {
			f.addAttr(FieldInitAttr.NULL_VALUE);
		}
	}
	int offset = cls.getStaticValuesOffset();
	if (offset == 0) {
		return;
	}
	Dex.Section section = dex.openSection(offset);
	StaticValuesParser parser = new StaticValuesParser(dex, section);
	parser.processFields(staticFields);

	// process const fields
	root().getConstValues().processConstFields(this, staticFields);
}
 

import com.android.dex.ClassDef; //导入依赖的package包/类
/**
 * Reads just enough data on each class so that we can sort it and then find
 * it later.
 */
private void readSortableTypes(SortableType[] sortableTypes, Dex buffer,
        IndexMap indexMap) {
    for (ClassDef classDef : buffer.classDefs()) {
        SortableType sortableType = indexMap.adjust(new SortableType(buffer, classDef));
        int t = sortableType.getTypeIndex();
        if (sortableTypes[t] == null) {
            sortableTypes[t] = sortableType;
        } else if (collisionPolicy != CollisionPolicy.KEEP_FIRST) {
            throw new DexException("Multiple dex files define "
                    + buffer.typeNames().get(classDef.getTypeIndex()));
        }
    }
}
 

import com.android.dex.ClassDef; //导入依赖的package包/类
/**
 * Assigns this type's depth if the depths of its supertype and implemented
 * interfaces are known. Returns false if the depth couldn't be computed
 * yet.
 */
public boolean tryAssignDepth(SortableType[] types) {
    int max;
    if (classDef.getSupertypeIndex() == ClassDef.NO_INDEX) {
        max = 0; // this is Object.class or an interface
    } else {
        SortableType sortableSupertype = types[classDef.getSupertypeIndex()];
        if (sortableSupertype == null) {
            max = 1; // unknown, so assume it's a root.
        } else if (sortableSupertype.depth == -1) {
            return false;
        } else {
            max = sortableSupertype.depth;
        }
    }

    for (short interfaceIndex : classDef.getInterfaces()) {
        SortableType implemented = types[interfaceIndex];
        if (implemented == null) {
            max = Math.max(max, 1); // unknown, so assume it's a root.
        } else if (implemented.depth == -1) {
            return false;
        } else {
            max = Math.max(max, implemented.depth);
        }
    }

    depth = max + 1;
    return true;
}
 

import com.android.dex.ClassDef; //导入依赖的package包/类
public ClassDef adjust(ClassDef classDef) {
    return new ClassDef(target, classDef.getOffset(), adjustType(classDef.getTypeIndex()),
            classDef.getAccessFlags(), adjustType(classDef.getSupertypeIndex()),
            adjustTypeListOffset(classDef.getInterfacesOffset()), classDef.getSourceFileIndex(),
            classDef.getAnnotationsOffset(), classDef.getClassDataOffset(),
            classDef.getStaticValuesOffset());
}
 

import com.android.dex.ClassDef; //导入依赖的package包/类
/**
 * Prints usages to out. Returns the number of matches found.
 */
public int grep() {
    for (ClassDef classDef : dex.classDefs()) {
        currentClass = classDef;
        currentMethod = null;

        if (classDef.getClassDataOffset() == 0) {
            continue;
        }

        ClassData classData = dex.readClassData(classDef);

        // find the strings in encoded constants
        int staticValuesOffset = classDef.getStaticValuesOffset();
        if (staticValuesOffset != 0) {
            readArray(new EncodedValueReader(dex.open(staticValuesOffset)));
        }

        // find the strings in method bodies
        for (ClassData.Method method : classData.allMethods()) {
            currentMethod = method;
            if (method.getCodeOffset() != 0) {
                codeReader.visitAll(dex.readCode(method).getInstructions());
            }
        }
    }

    currentClass = null;
    currentMethod = null;
    return count;
}
 

import com.android.dex.ClassDef; //导入依赖的package包/类
/**
 * Prints usages to out.
 */
public void findUsages() {
    if (fieldIds == null || methodIds == null) {
        return;
    }

    for (ClassDef classDef : dex.classDefs()) {
        currentClass = classDef;
        currentMethod = null;

        if (classDef.getClassDataOffset() == 0) {
            continue;
        }

        ClassData classData = dex.readClassData(classDef);
        for (ClassData.Field field : classData.allFields()) {
            int fieldIndex = field.getFieldIndex();
            if (fieldIds.contains(fieldIndex)) {
                out.println(location() + " field declared " + dex.fieldIds().get(fieldIndex));
            }
        }

        for (ClassData.Method method : classData.allMethods()) {
            currentMethod = method;
            int methodIndex = method.getMethodIndex();
            if (methodIds.contains(methodIndex)) {
                out.println(location() + " method declared " + dex.methodIds().get(methodIndex));
            }
            if (method.getCodeOffset() != 0) {
                codeReader.visitAll(dex.readCode(method).getInstructions());
            }
        }
    }

    currentClass = null;
    currentMethod = null;
}
 

import com.android.dex.ClassDef; //导入依赖的package包/类
private void printClassDefs() {
    int index = 0;
    for (ClassDef classDef : dex.classDefs()) {
        System.out.println("class def " + index + ": " + classDef);
        index++;
    }
}
 

import com.android.dex.ClassDef; //导入依赖的package包/类
/**
 * Reads just enough data on each class so that we can sort it and then find
 * it later.
 */
private void readSortableTypes(SortableType[] sortableTypes, Dex buffer,
        IndexMap indexMap) {
    for (ClassDef classDef : buffer.classDefs()) {
        SortableType sortableType = indexMap.adjust(
                new SortableType(buffer, indexMap, classDef));
        int t = sortableType.getTypeIndex();
        if (sortableTypes[t] == null) {
            sortableTypes[t] = sortableType;
        } else if (collisionPolicy != CollisionPolicy.KEEP_FIRST) {
            throw new DexException("Multiple dex files define "
                    + buffer.typeNames().get(classDef.getTypeIndex()));
        }
    }
}
 

import com.android.dex.ClassDef; //导入依赖的package包/类
/**
 * Assigns this type's depth if the depths of its supertype and implemented
 * interfaces are known. Returns false if the depth couldn't be computed
 * yet.
 */
public boolean tryAssignDepth(SortableType[] types) {
    int max;
    if (classDef.getSupertypeIndex() == ClassDef.NO_INDEX) {
        max = 0; // this is Object.class or an interface
    } else if (classDef.getSupertypeIndex() == classDef.getTypeIndex()) {
        // This is an invalid class extending itself.
        throw new DexException("Class with type index " + classDef.getTypeIndex()
                + " extends itself");
    } else {
        SortableType sortableSupertype = types[classDef.getSupertypeIndex()];
        if (sortableSupertype == null) {
            max = 1; // unknown, so assume it's a root.
        } else if (sortableSupertype.depth == -1) {
            return false;
        } else {
            max = sortableSupertype.depth;
        }
    }

    for (short interfaceIndex : classDef.getInterfaces()) {
        SortableType implemented = types[interfaceIndex];
        if (implemented == null) {
            max = Math.max(max, 1); // unknown, so assume it's a root.
        } else if (implemented.depth == -1) {
            return false;
        } else {
            max = Math.max(max, implemented.depth);
        }
    }

    depth = max + 1;
    return true;
}
 

import com.android.dex.ClassDef; //导入依赖的package包/类
private void loadAnnotations(ClassDef cls) {
	int offset = cls.getAnnotationsOffset();
	if (offset != 0) {
		try {
			new AnnotationsParser(this).parse(offset);
		} catch (Exception e) {
			LOG.error("Error parsing annotations in {}", this, e);
		}
	}
}
 

import com.android.dex.ClassDef; //导入依赖的package包/类
public void loadClasses() throws DecodeException {
	for (ClassDef cls : dexBuf.classDefs()) {
		ClassNode clsNode = new ClassNode(this, cls);
		classes.add(clsNode);
		clsMap.put(clsNode.getClassInfo(), clsNode);
	}
}
 

import com.android.dex.ClassDef; //导入依赖的package包/类
private Multimap<String, String> assertMultidexOutput(int expectedClassCount,
    Path outputArchive, Set<String> mainDexList) throws IOException {
  SetMultimap<String, String> dexFiles = HashMultimap.create();
  try (ZipFile output = new ZipFile(outputArchive.toFile())) {
    Enumeration<? extends ZipEntry> entries = output.entries();
    while (entries.hasMoreElements()) {
      ZipEntry entry = entries.nextElement();
      assertThat(entry.getName()).containsMatch("classes[2-9]?.dex");
      Dex dex = new Dex(output.getInputStream(entry));
      for (ClassDef clazz : dex.classDefs()) {
        dexFiles.put(entry.getName(),
            toSlashedClassName(dex.typeNames().get(clazz.getTypeIndex())));
      }
    }
  }
  assertThat(dexFiles.keySet().size()).isAtLeast(2); // test sanity
  assertThat(dexFiles.size()).isAtLeast(1); // test sanity
  assertThat(dexFiles).hasSize(expectedClassCount);
  for (int i = 0; i < dexFiles.keySet().size(); ++i) {
    assertThat(dexFiles).containsKey(expectedDexFileName(i));
  }
  for (int i = 1; i < dexFiles.keySet().size(); ++i) {
    Set<String> prev = dexFiles.get(expectedDexFileName(i - 1));
    if (i == 1) {
      prev = Sets.difference(prev, mainDexList);
    }
    Set<String> shard = dexFiles.get(expectedDexFileName(i));
    for (String c1 : prev) {
      for (String c2 : shard) {
        assertThat(ZipEntryComparator.compareClassNames(c2, c1))
            .named(c2 + " in shard " + i + " should compare as larger than " + c1
                + "; list of all shards for reference: " + dexFiles)
            .isGreaterThan(0);
      }
    }
  }
  return dexFiles;
}
 

import com.android.dex.ClassDef; //导入依赖的package包/类
public void loadClasses() {
	for (ClassDef cls : dexBuf.classDefs()) {
		ClassNode clsNode = new ClassNode(this, cls);
		classes.add(clsNode);
		clsMap.put(clsNode.getClassInfo(), clsNode);
	}
}