--- /dev/null
+/*
+ * Copyright (C) 2009 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dex.reader;
+
+import java.lang.reflect.Modifier;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import dex.reader.DexFileReader.ClassDefItem;
+import dex.reader.DexFileReader.FieldIdItem;
+import dex.reader.DexFileReader.MethodsIdItem;
+import dex.reader.DexFileReader.ProtIdItem;
+import dex.structure.DexAnnotation;
+import dex.structure.DexClass;
+import dex.structure.DexField;
+import dex.structure.DexMethod;
+
+/* package */final class DexClassImpl implements DexClass {
+ // constant
+ private final int NO_INDEX = -1;
+ // dex bytes
+ private final DexBuffer buffer;
+ // allready parsed
+ private final ClassDefItem classDefItem;
+ private final int[] typeIds;
+ private final String[] stringPool;
+ private ProtIdItem[] protoIdItems;
+ private FieldIdItem[] fieldIdItems;
+ private MethodsIdItem[] methodIdItems;
+
+ //
+ private List<DexField> fields;
+ private List<DexMethod> methods;
+ private List<String> interfaces;
+ private ClassDataItem classDataItem;
+ private AnnotationsDirectoryItem annotationDir;
+ private Map<Integer, FieldAnnotation> idToFieldAnnotation =
+ new HashMap<Integer, FieldAnnotation>();
+ private Map<Integer, MethodAnnotation> idToMethodAnnotation =
+ new HashMap<Integer, MethodAnnotation>();
+ private Map<Integer, ParameterAnnotation> idToParameterAnnotation =
+ new HashMap<Integer, ParameterAnnotation>();
+
+ private Set<DexAnnotation> annotations;
+ private TypeFormatter formatter = new TypeFormatter();
+
+ private boolean hasClassData;
+
+
+ public DexClassImpl(DexBuffer buffer, ClassDefItem classDefItem,
+ String[] stringPool, int[] typeIds, ProtIdItem[] protoIdItems,
+ FieldIdItem[] fieldIdItems, MethodsIdItem[] methodIdItems) {
+ this.buffer = buffer;
+ this.classDefItem = classDefItem;
+ this.stringPool = stringPool;
+ this.typeIds = typeIds;
+ this.protoIdItems = protoIdItems;
+ this.fieldIdItems = fieldIdItems;
+ this.methodIdItems = methodIdItems;
+ hasClassData = classDefItem.class_data_off != 0;
+ parseClassData();
+ parseAnnotationDirectory();
+ parseClassAnnotations();
+ }
+
+ static class AnnotationsDirectoryItem {
+ int class_annotations_off; // uint
+ int fields_size; // uint
+ int methods_size; // uint
+ int annotated_params_size; // uint
+ FieldAnnotation[] fieldAnnotations;
+ MethodAnnotation[] methodAnnotations;
+ ParameterAnnotation[] parameterAnnotations;
+ }
+
+ static class AnnotationSetItem {
+ int size;// uint
+ int[] annotationOffItem;
+ }
+
+ static class FieldAnnotation {
+ int fieldIdx;// uint
+ int annotationsOff;// uint
+ AnnotationSetItem[] annotationSetItems;
+ }
+
+ static class MethodAnnotation {
+ int methodIdx;// uint
+ int annotationsOff;// uint
+ AnnotationSetItem[] annotationSetItems;
+ }
+
+ static class ParameterAnnotation {
+ int methodIdx;// uint
+ int annotationsOff;// uint
+ // AnnotationSetRefListItem[] annotationSetRefListItems;
+ }
+
+ private void parseAnnotationDirectory() {
+ if (classDefItem.annotations_off != 0) {
+ buffer.setPosition(classDefItem.annotations_off);
+ annotationDir = new AnnotationsDirectoryItem();
+ annotationDir.class_annotations_off = buffer.readUInt();
+ annotationDir.fields_size = buffer.readUInt();
+ annotationDir.methods_size = buffer.readUInt();
+ annotationDir.annotated_params_size = buffer.readUInt();
+
+ if (annotationDir.fields_size != 0) {
+ annotationDir.fieldAnnotations =
+ new FieldAnnotation[annotationDir.fields_size];
+ for (int i = 0; i < annotationDir.fields_size; i++) {
+ annotationDir.fieldAnnotations[i] = new FieldAnnotation();
+ annotationDir.fieldAnnotations[i].fieldIdx = buffer
+ .readUInt();
+ annotationDir.fieldAnnotations[i].annotationsOff = buffer
+ .readUInt();
+ idToFieldAnnotation.put(
+ annotationDir.fieldAnnotations[i].fieldIdx,
+ annotationDir.fieldAnnotations[i]);
+ }
+ }
+ if (annotationDir.methods_size != 0) {
+ annotationDir.methodAnnotations =
+ new MethodAnnotation[annotationDir.methods_size];
+ for (int i = 0; i < annotationDir.methods_size; i++) {
+ annotationDir.methodAnnotations[i] = new MethodAnnotation();
+ annotationDir.methodAnnotations[i].methodIdx = buffer
+ .readUInt();
+ annotationDir.methodAnnotations[i].annotationsOff = buffer
+ .readUInt();
+ idToMethodAnnotation.put(
+ annotationDir.methodAnnotations[i].methodIdx,
+ annotationDir.methodAnnotations[i]);
+ }
+ }
+ if (annotationDir.annotated_params_size != 0) {
+ annotationDir.parameterAnnotations =
+ new ParameterAnnotation[annotationDir
+ .annotated_params_size];
+ for (int i = 0; i < annotationDir.annotated_params_size; i++) {
+ annotationDir.parameterAnnotations[i] =
+ new ParameterAnnotation();
+ annotationDir.parameterAnnotations[i].methodIdx = buffer
+ .readUInt();
+ annotationDir.parameterAnnotations[i].annotationsOff =
+ buffer.readUInt();
+ idToParameterAnnotation.put(
+ annotationDir.parameterAnnotations[i].methodIdx,
+ annotationDir.parameterAnnotations[i]);
+ }
+ }
+ }
+ }
+
+ static class ClassDataItem {
+ int static_fields_size;// uleb128
+ int instance_fields_size;// uleb128
+ int direct_methods_size;// uleb128
+ int virtual_methods_size;// uleb128
+ EncodedField[] staticFields;
+ EncodedField[] instanceFields;
+ EncodedMethod[] directMethods;
+ EncodedMethod[] virtualMethods;
+ }
+
+ static class EncodedField {
+ int field_idx_diff; // uleb128
+ int access_flags; // uleb128
+ }
+
+ static class EncodedMethod {
+ int method_idx_diff;// uleb128
+ int access_flags;// uleb128
+ int code_off; // uleb128
+ }
+
+ private void parseClassData() {
+ if (hasClassData) {
+ buffer.setPosition(classDefItem.class_data_off);
+ classDataItem = new ClassDataItem();
+ classDataItem.static_fields_size = buffer.readUleb128();
+ classDataItem.instance_fields_size = buffer.readUleb128();
+ classDataItem.direct_methods_size = buffer.readUleb128();
+ classDataItem.virtual_methods_size = buffer.readUleb128();
+ classDataItem.staticFields = parseFields(
+ classDataItem.static_fields_size);
+ classDataItem.instanceFields = parseFields(
+ classDataItem.instance_fields_size);
+ classDataItem.directMethods = parseMethods(
+ classDataItem.direct_methods_size);
+ classDataItem.virtualMethods = parseMethods(
+ classDataItem.virtual_methods_size);
+ }
+ }
+
+ private EncodedField[] parseFields(int size) {
+ EncodedField[] fields = new EncodedField[size];
+ for (int i = 0; i < fields.length; i++) {
+ fields[i] = new EncodedField();
+ fields[i].field_idx_diff = buffer.readUleb128();
+ fields[i].access_flags = buffer.readUleb128();
+ }
+ return fields;
+ }
+
+ private EncodedMethod[] parseMethods(int size) {
+ EncodedMethod[] methods = new EncodedMethod[size];
+ for (int i = 0; i < methods.length; i++) {
+ methods[i] = new EncodedMethod();
+ methods[i].method_idx_diff = buffer.readUleb128();
+ methods[i].access_flags = buffer.readUleb128();
+ methods[i].code_off = buffer.readUleb128();
+ }
+ return methods;
+ }
+
+ private void parseClassAnnotations() {
+ annotations = new HashSet<DexAnnotation>();
+ if (annotationDir != null && annotationDir.class_annotations_off != 0) {
+ buffer.setPosition(annotationDir.class_annotations_off);
+ final int size = buffer.readUInt();
+ for (int i = 0; i < size; i++) {
+ annotations.add(new DexAnnotationImpl(buffer.createCopy(),
+ buffer.readUInt(), typeIds, stringPool, fieldIdItems));
+ }
+ }
+ }
+
+ public synchronized List<DexField> getFields() {
+ if (fields == null) {
+ fields = new ArrayList<DexField>();
+ if (hasClassData) {
+ fields.addAll(getDexFields(classDataItem.staticFields));
+ fields.addAll(getDexFields(classDataItem.instanceFields));
+ }
+ }
+ return fields;
+ }
+
+ private List<DexField> getDexFields(EncodedField[] fields) {
+ List<DexField> dexFields = new ArrayList<DexField>(fields.length);
+ if (fields.length != 0) {
+ int fieldIdIdx = 0;
+ for (int i = 0; i < fields.length; i++) {
+ int accessFlags = fields[i].access_flags;
+ fieldIdIdx = (i == 0) ? fields[i].field_idx_diff : fieldIdIdx
+ + fields[i].field_idx_diff;
+ dexFields.add(new DexFieldImpl(buffer.createCopy(), this,
+ fieldIdItems[fieldIdIdx], accessFlags,
+ idToFieldAnnotation.get(fieldIdIdx), stringPool,
+ typeIds, fieldIdItems));
+ }
+ }
+ return dexFields;
+ }
+
+ public synchronized List<DexMethod> getMethods() {
+ if (methods == null) {
+ methods = new ArrayList<DexMethod>();
+ if (hasClassData) {
+ methods.addAll(getDexMethods(classDataItem.directMethods));
+ methods.addAll(getDexMethods(classDataItem.virtualMethods));
+ }
+ }
+ return methods;
+ }
+
+ private List<DexMethod> getDexMethods(EncodedMethod[] methods) {
+ List<DexMethod> dexMethods = new ArrayList<DexMethod>(methods.length);
+ if (methods.length != 0) {
+ int methodIdIdx = 0;
+ EncodedMethod method = null;
+ for (int i = 0; i < methods.length; i++) {
+ method = methods[i];
+ methodIdIdx = (i == 0) ? method.method_idx_diff : methodIdIdx
+ + method.method_idx_diff;
+ dexMethods.add(new DexMethodImpl(buffer, this,
+ methodIdItems[methodIdIdx],
+ protoIdItems[methodIdItems[methodIdIdx].proto_idx],
+ method.access_flags, idToMethodAnnotation
+ .get(methodIdIdx), idToParameterAnnotation
+ .get(methodIdIdx), stringPool, typeIds,
+ fieldIdItems));
+ }
+ }
+ return dexMethods;
+ }
+
+
+
+ public synchronized List<String> getInterfaces() {
+ if (interfaces == null) {
+ interfaces = new LinkedList<String>();
+ if (classDefItem.interfaces_off != 0) {
+ buffer.setPosition(classDefItem.interfaces_off);
+ int size = buffer.readUInt();
+ for (int i = 0; i < size; i++) {
+ interfaces.add(stringPool[typeIds[buffer.readUShort()]]);
+ }
+ }
+ }
+ return interfaces;
+ }
+
+ // returns null if no super class is present
+ public String getSuperClass() {
+ return classDefItem.superclass_idx == NO_INDEX ? null
+ : stringPool[typeIds[classDefItem.superclass_idx]];
+ }
+
+ public Set<DexAnnotation> getAnnotations() {
+ return annotations;
+ }
+
+ public String getName() {
+ return stringPool[typeIds[classDefItem.class_idx]];
+ }
+
+ public int getModifiers() {
+ return classDefItem.access_flags;
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder builder = new StringBuilder();
+ builder.append(formatter.formatAnnotations(getAnnotations()));
+ builder.append(Modifier.toString(getModifiers()));
+ builder.append(" class ");
+ builder.append(formatter.format(getName()));
+ if (getSuperClass() != null) {
+ builder.append(" extends ");
+ builder.append(formatter.format(getSuperClass()));
+ }
+ if (!getInterfaces().isEmpty()) {
+ builder.append(" implements ");
+ builder.append(formatter.format(getInterfaces()));
+ }
+ return builder.toString();
+ }
+
+}
OSDN Git Service
