How to use org.jf.dexlib2.dexbacked

private int getDirectMethodsOffset() {
  if (directMethodsOffset > 0) {
    return directMethodsOffset;
  }
  DexReader reader = dexFile.readerAt(getInstanceFieldsOffset());
  DexBackedField.skipFields(reader, instanceFieldCount);
  directMethodsOffset = reader.getOffset();
  return directMethodsOffset;
}

private int getVirtualMethodsOffset() {
  if (virtualMethodsOffset > 0) {
    return virtualMethodsOffset;
  }
  DexReader reader = dexFile.readerAt(getDirectMethodsOffset());
  DexBackedMethod.skipMethods(reader, directMethodCount);
  virtualMethodsOffset = reader.getOffset();
  return virtualMethodsOffset;
}

private int getInstanceFieldsOffset() {
  if (instanceFieldsOffset > 0) {
    return instanceFieldsOffset;
  }
  DexReader reader = new DexReader(dexFile, staticFieldsOffset);
  DexBackedField.skipFields(reader, staticFieldCount);
  instanceFieldsOffset = reader.getOffset();
  return instanceFieldsOffset;
}

@Nonnull
public String getString(int stringIndex) {
  int stringOffset = getStringIdItemOffset(stringIndex);
  int stringDataOffset = readSmallUint(stringOffset);
  DexReader reader = readerAt(stringDataOffset);
  int utf16Length = reader.readSmallUleb128();
  return reader.readString(utf16Length);
}

public int getCallSiteIdItemOffset(int callSiteIndex) {
  MapItem mapItem = getMapItemForSection(ItemType.CALL_SITE_ID_ITEM);
  if (mapItem == null || callSiteIndex >= mapItem.getItemCount()) {
    throw new InvalidItemIndex(callSiteIndex, "Call site index out of bounds: %d", callSiteIndex);
  }
  return mapItem.getOffset() + callSiteIndex * CallSiteIdItem.ITEM_SIZE;
}

@Nonnull
@Override
public String getName() {
  return dexFile.getString(dexFile.readSmallUint(getMethodIdItemOffset() + MethodIdItem.NAME_OFFSET));
}

private int getProtoIdItemOffset() {
  if (protoIdItemOffset == 0) {
    int protoIndex = dexFile.readUshort(getMethodIdItemOffset() + MethodIdItem.PROTO_OFFSET);
    protoIdItemOffset = dexFile.getProtoIdItemOffset(protoIndex);
  }
  return protoIdItemOffset;
}

private int getParametersOffset() {
  if (parametersOffset == -1) {
    parametersOffset = dexFile.readSmallUint(getProtoIdItemOffset() + ProtoIdItem.PARAMETERS_OFFSET);
  }
  return parametersOffset;
}

  public static int getEndian(byte[] buf, int offset) {
    BaseDexBuffer bdb = new BaseDexBuffer(buf);
    return bdb.readInt(offset + ENDIAN_TAG_OFFSET);
  }
}

public AnnotationIteratorImpl(int startOffset, int size) {
  this.startOffset = startOffset;
  this.size = size;
  this.currentItemIndex = dexFile.readSmallUint(startOffset);
  this.currentIndex = 0;
}

public int getStringIdItemOffset(int stringIndex) {
  if (stringIndex < 0 || stringIndex >= stringCount) {
    throw new InvalidItemIndex(stringIndex, "String index out of bounds: %d", stringIndex);
  }
  return stringStartOffset + stringIndex*StringIdItem.ITEM_SIZE;
}

private int getMethodIdItemOffset() {
  if (methodIdItemOffset == 0) {
    methodIdItemOffset = dexFile.getMethodIdItemOffset(methodIndex);
  }
  return methodIdItemOffset;
}

public int getMethodHandleItemOffset(int methodHandleIndex) {
  MapItem mapItem = getMapItemForSection(ItemType.METHOD_HANDLE_ITEM);
  if (mapItem == null || methodHandleIndex >= mapItem.getItemCount()) {
    throw new InvalidItemIndex(methodHandleIndex , "Method handle index out of bounds: %d", methodHandleIndex);
  }
  return mapItem.getOffset() + methodHandleIndex * MethodHandleItem.ITEM_SIZE;
}

  public void reset() {
    this.currentItemIndex = dexFile.readSmallUint(startOffset);
    this.currentIndex = 0;
  }
}

public int getClassDefItemOffset(int classIndex) {
  if (classIndex < 0 || classIndex >= classCount) {
    throw new InvalidItemIndex(classIndex, "Class index out of bounds: %d", classIndex);
  }
  return classStartOffset + classIndex*ClassDefItem.ITEM_SIZE;
}

public int seekTo(int itemIndex) {
  while (currentItemIndex < itemIndex && (currentIndex+1) < size) {
    currentIndex++;
    currentItemIndex = dexFile.readSmallUint(startOffset + (currentIndex*8));
  }
  if (currentItemIndex == itemIndex) {
    return dexFile.readSmallUint(startOffset + (currentIndex*8)+4);
  }
  return 0;
}

public int getTypeIdItemOffset(int typeIndex) {
  if (typeIndex < 0 || typeIndex >= typeCount) {
    throw new InvalidItemIndex(typeIndex, "Type index out of bounds: %d", typeIndex);
  }
  return typeStartOffset + typeIndex*TypeIdItem.ITEM_SIZE;
}

public int getMethodIdItemOffset(int methodIndex) {
  if (methodIndex < 0 || methodIndex >= methodCount) {
    throw new InvalidItemIndex(methodIndex, "Method index out of bounds: %d", methodIndex);
  }
  return methodStartOffset + methodIndex*MethodIdItem.ITEM_SIZE;
}

public int getProtoIdItemOffset(int protoIndex) {
  if (protoIndex < 0 || protoIndex >= protoCount) {
    throw new InvalidItemIndex(protoIndex, "Proto index out of bounds: %d", protoIndex);
  }
  return protoStartOffset + protoIndex*ProtoIdItem.ITEM_SIZE;
}

public int getFieldIdItemOffset(int fieldIndex) {
  if (fieldIndex < 0 || fieldIndex >= fieldCount) {
    throw new InvalidItemIndex(fieldIndex, "Field index out of bounds: %d", fieldIndex);
  }
  return fieldStartOffset + fieldIndex*FieldIdItem.ITEM_SIZE;
}