import org.jf.dexlib.Util.Input; //导入依赖的package包/类
public OdexHeader(Input in) {
    magic = in.readBytes(8);

    if (Arrays.equals(MAGIC_35, magic)) {
        version = 35;
    } else if (Arrays.equals(MAGIC_36, magic)) {
        version = 36;
    } else {
        throw new RuntimeException("The magic value is not one of the expected values");
    }

    dexOffset = in.readInt();
    dexLength = in.readInt();
    depsOffset = in.readInt();
    depsLength = in.readInt();
    auxOffset = in.readInt();
    auxLength = in.readInt();
    flags = in.readInt();
    in.readInt(); //padding
}
 

import org.jf.dexlib.Util.Input; //导入依赖的package包/类
public OdexDependencies (Input in) {
    modificationTime = in.readInt();
    crc = in.readInt();
    dalvikBuild = in.readInt();

    int dependencyCount = in.readInt();

    dependencies = new String[dependencyCount];
    dependencyChecksums = new byte[dependencyCount][];

    for (int i=0; i<dependencyCount; i++) {
        int stringLength = in.readInt();

        try {
            dependencies[i] = new String(in.readBytes(stringLength), 0, stringLength-1, "US-ASCII");
        } catch (UnsupportedEncodingException ex) {
            throw new RuntimeException(ex);
        }
        dependencyChecksums[i] = in.readBytes(20);
    }
}
 

import org.jf.dexlib.Util.Input; //导入依赖的package包/类
/** {@inheritDoc} */
protected void readItem(Input in, ReadContext readContext) {
    int size = in.readInt();

    for (int i=0; i<size; i++) {
        ItemType itemType = ItemType.fromInt(in.readShort());

        //unused
        in.readShort();

        int sectionSize = in.readInt();
        int sectionOffset = in.readInt();

        readContext.addSection(itemType, sectionSize, sectionOffset);
    }
}
 

import org.jf.dexlib.Util.Input; //导入依赖的package包/类
/** {@inheritDoc} */
protected void readItem(Input in, ReadContext readContext) {
    classType = dexFile.TypeIdsSection.getItemByIndex(in.readInt());
    accessFlags = in.readInt();
    superType = dexFile.TypeIdsSection.getOptionalItemByIndex(in.readInt());
    implementedInterfaces = (TypeListItem)readContext.getOptionalOffsettedItemByOffset(ItemType.TYPE_TYPE_LIST,
            in.readInt());
    sourceFile = dexFile.StringIdsSection.getOptionalItemByIndex(in.readInt());
    annotations = (AnnotationDirectoryItem)readContext.getOptionalOffsettedItemByOffset(
            ItemType.TYPE_ANNOTATIONS_DIRECTORY_ITEM, in.readInt());
    classData = (ClassDataItem)readContext.getOptionalOffsettedItemByOffset(ItemType.TYPE_CLASS_DATA_ITEM, in.readInt());
    staticFieldInitializers = (EncodedArrayItem)readContext.getOptionalOffsettedItemByOffset(
            ItemType.TYPE_ENCODED_ARRAY_ITEM, in.readInt());

    if (classData != null) {
        classData.setParent(this);
    }
    if (annotations != null) {
        annotations.setParent(this);
    }
}
 

import org.jf.dexlib.Util.Input; //导入依赖的package包/类
public OdexHeaderItem(Input in) {
    magic = in.readBytes(8);

    for (int i=0; i<8; i++) {
        if (MAGIC[i] != magic[i]) {
            throw new RuntimeException("The magic value is not the expected value");
        }
    }

    dexOffset = in.readInt();
    dexLength = in.readInt();
    depsOffset = in.readInt();
    depsLength = in.readInt();
    auxOffset = in.readInt();
    auxLength = in.readInt();
    flags = in.readInt();
    in.readInt(); //padding
}
 

import org.jf.dexlib.Util.Input; //导入依赖的package包/类
/**
 * Read the specified number of items from the given <code>Input</code> object
 * @param size The number of items to read
 * @param in The <code>Input</code> object to read from
 * @param readContext a <code>ReadContext</code> object to hold information that is
 * only needed while reading in a file
 */
protected void readFrom(int size, Input in, ReadContext readContext) {
    //readItems() expects that the list will already be the correct size, so add null items
    //until we reach the specified size
    items.ensureCapacity(size);
    for (int i = items.size(); i < size; i++) {
        items.add(null);
    }

    in.alignTo(ItemType.ItemAlignment);
    offset = in.getCursor();

    //call the subclass's method that actually reads in the items
    readItems(in, readContext);
}
 

import org.jf.dexlib.Util.Input; //导入依赖的package包/类
/** {@inheritDoc} */
protected void readItem(Input in, ReadContext readContext) {
    annotations = new AnnotationItem[in.readInt()];

    for (int i=0; i<annotations.length; i++) {
        annotations[i] = (AnnotationItem)readContext.getOffsettedItemByOffset(ItemType.TYPE_ANNOTATION_ITEM,
                in.readInt());
    }
}
 

import org.jf.dexlib.Util.Input; //导入依赖的package包/类
/**
 * Constructs a new <code>ArrayEncodedSubValue</code> by reading the value from the given <code>Input</code> object.
 * The <code>Input</code>'s cursor should be set to the 2nd byte of the encoded value
 * @param dexFile The <code>DexFile</code> that is being read in
 * @param in The <code>Input</code> object to read from
 */
public ArrayEncodedSubValue(DexFile dexFile, Input in) {
    values = new EncodedValue[in.readUnsignedLeb128()];

    for (int i=0; i<values.length; i++) {
        values[i] = EncodedValue.readEncodedValue(dexFile, in);
    }
}
 

import org.jf.dexlib.Util.Input; //导入依赖的package包/类
/**
* Constructs a new <code>AnnotationEncodedSubValue</code> by reading the value from the given <code>Input</code>
* object.
* @param dexFile The <code>DexFile</code> that is being read in
* @param in The <code>Input</code> object to read from
*/
public AnnotationEncodedSubValue(DexFile dexFile, Input in) {
    annotationType = dexFile.TypeIdsSection.getItemByIndex(in.readUnsignedLeb128());
    names = new StringIdItem[in.readUnsignedLeb128()];
    values = new EncodedValue[names.length];

    for (int i=0; i<names.length; i++) {
        names[i] = dexFile.StringIdsSection.getItemByIndex(in.readUnsignedLeb128());
        values[i] = EncodedValue.readEncodedValue(dexFile, in);
    }
}
 

import org.jf.dexlib.Util.Input; //导入依赖的package包/类
/** {@inheritDoc} */
protected void readItems(Input in, ReadContext readContext) {
    for (int i = 0; i < items.size(); i++) {
        T item = (T)ItemFactory.makeItem(ItemType, DexFile);
        items.set(i, item);
        item.readFrom(in, i, readContext);
    }
}
 

import org.jf.dexlib.Util.Input; //导入依赖的package包/类
/**
 * Read in the item from the given input stream, and initialize the index
 * @param in the <code>Input</code> object to read from
 * @param index the index within the containing section of the item being read in
 * @param readContext a <code>ReadContext</code> object to hold information that is
 * only needed while reading in a file
 */
protected void readFrom(Input in, int index, ReadContext readContext) {
    try {
        assert AlignmentUtils.isAligned(in.getCursor(), getItemType().ItemAlignment);

        this.offset = in.getCursor();
        this.index = index;

        this.readItem(in, readContext);
    } catch (Exception ex) {
        throw addExceptionContext(ex);
    }
}
 

import org.jf.dexlib.Util.Input; //导入依赖的package包/类
/** {@inheritDoc} */
protected void readItem(Input in, ReadContext readContext) {
    annotationSets = new AnnotationSetItem[in.readInt()];

    for (int i=0; i<annotationSets.length; i++) {
        annotationSets[i] = (AnnotationSetItem)readContext.getOptionalOffsettedItemByOffset(
                ItemType.TYPE_ANNOTATION_SET_ITEM, in.readInt());
    }
}
 

import org.jf.dexlib.Util.Input; //导入依赖的package包/类
/** {@inheritDoc} */
protected void readItem(Input in, ReadContext readContext) {
    int stringDataOffset = in.readInt();

    stringDataItem = (StringDataItem)readContext.getOffsettedItemByOffset(ItemType.TYPE_STRING_DATA_ITEM,
            stringDataOffset);
}
 

import org.jf.dexlib.Util.Input; //导入依赖的package包/类
/** {@inheritDoc} */
protected void readItem(Input in, ReadContext readContext) {
    int size = in.readInt();
    typeList = new TypeIdItem[size];
    for (int i=0; i<size; i++) {
        int typeIndex = in.readShort();
        typeList[i] = dexFile.TypeIdsSection.getItemByIndex(typeIndex);
    }
}
 

import org.jf.dexlib.Util.Input; //导入依赖的package包/类
/** {@inheritDoc} */
protected void readItem(Input in, ReadContext readContext) {
    classType = dexFile.TypeIdsSection.getItemByIndex(in.readInt());
    accessFlags = in.readInt();
    superType = dexFile.TypeIdsSection.getOptionalItemByIndex(in.readInt());
    implementedInterfaces = (TypeListItem)readContext.getOptionalOffsettedItemByOffset(ItemType.TYPE_TYPE_LIST,
            in.readInt());
    sourceFile = dexFile.StringIdsSection.getOptionalItemByIndex(in.readInt());
    annotations = (AnnotationDirectoryItem)readContext.getOptionalOffsettedItemByOffset(
            ItemType.TYPE_ANNOTATIONS_DIRECTORY_ITEM, in.readInt());
    classData = (ClassDataItem)readContext.getOptionalOffsettedItemByOffset(ItemType.TYPE_CLASS_DATA_ITEM, in.readInt());
    staticFieldInitializers = (EncodedArrayItem)readContext.getOptionalOffsettedItemByOffset(
            ItemType.TYPE_ENCODED_ARRAY_ITEM, in.readInt());
}
 

import org.jf.dexlib.Util.Input; //导入依赖的package包/类
public static EncodedValue readEncodedValue(DexFile dexFile, Input in) {
    Byte b = in.readByte();
    ValueType valueType = ValueType.fromByte((byte)(b & 0x1f));
    byte valueArg = (byte)((b & 0xFF) >> 5);

    switch (valueType) {
        case VALUE_BYTE:
            return new ByteEncodedValue(in);
        case VALUE_SHORT:
            return new ShortEncodedValue(in, valueArg);
        case VALUE_CHAR:
            return new CharEncodedValue(in, valueArg);
        case VALUE_INT:
            return new IntEncodedValue(in, valueArg);
        case VALUE_LONG:
            return new LongEncodedValue(in, valueArg);
        case VALUE_FLOAT:
            return new FloatEncodedValue(in, valueArg);
        case VALUE_DOUBLE:
            return new DoubleEncodedValue(in, valueArg);
        case VALUE_STRING:
            return new StringEncodedValue(dexFile, in, valueArg);
        case VALUE_TYPE:
            return new TypeEncodedValue(dexFile, in, valueArg);
        case VALUE_FIELD:
            return new FieldEncodedValue(dexFile, in, valueArg);
        case VALUE_METHOD:
            return new MethodEncodedValue(dexFile, in, valueArg);
        case VALUE_ENUM:
            return new EnumEncodedValue(dexFile, in, valueArg);
        case VALUE_ARRAY:
            return new ArrayEncodedValue(dexFile, in);
        case VALUE_ANNOTATION:
            return new AnnotationEncodedValue(dexFile, in);
        case VALUE_NULL:
            return NullEncodedValue.NullValue;
        case VALUE_BOOLEAN:
            return BooleanEncodedValue.getBooleanEncodedValue(valueArg);
    }
    return null;
}
 

import org.jf.dexlib.Util.Input; //导入依赖的package包/类
/** {@inheritDoc} */
protected void readItem(Input in, ReadContext readContext) {
    shortyDescriptor = dexFile.StringIdsSection.getItemByIndex(in.readInt());
    returnType = dexFile.TypeIdsSection.getItemByIndex(in.readInt());
    parameters = (TypeListItem)readContext.getOptionalOffsettedItemByOffset(ItemType.TYPE_TYPE_LIST, in.readInt());
}