import org.jf.dexlib2.AnnotationVisibility; //导入依赖的package包/类
public static void writeTo(@Nonnull IndentingWriter writer, @Nonnull Annotation annotation,
                           @Nullable String containingClass) throws IOException {
    writer.write(".annotation ");
    writer.write(AnnotationVisibility.getVisibility(annotation.getVisibility()));
    writer.write(' ');
    writer.write(annotation.getType());
    writer.write('\n');

    AnnotationEncodedValueAdaptor.writeElementsTo(writer, annotation.getElements(), containingClass);

    writer.write(".end annotation\n");
}
 

import org.jf.dexlib2.AnnotationVisibility; //导入依赖的package包/类
public static void writeTo(IndentingWriter writer, Annotation annotation) throws IOException {
    writer.write(".annotation ");
    writer.write(AnnotationVisibility.getVisibility(annotation.getVisibility()));
    writer.write(' ');
    writer.write(annotation.getType());
    writer.write('\n');

    AnnotationEncodedValueAdaptor.writeElementsTo(writer, annotation.getElements());

    writer.write(".end annotation\n");
}
 

import org.jf.dexlib2.AnnotationVisibility; //导入依赖的package包/类
private Annotation buildEnclosingMethodTag(EnclosingMethodTag t, Set<String> skipList) {
	if (!skipList.add("Ldalvik/annotation/EnclosingMethod;"))
		return null;
	
	if (t.getEnclosingMethod() == null)
		return null;

	String[] split1 = t.getEnclosingMethodSig().split("\\)");
 String parametersS = split1[0].replaceAll("\\(", "");
 String returnTypeS = split1[1];
 
 List<String> typeList = new ArrayList<String>();
    if (!parametersS.equals("")) {
        for (String p : Util.splitParameters(parametersS)) {
            if (!p.isEmpty())
            	typeList.add(p);
        }
    }
    
 ImmutableMethodReference mRef = new ImmutableMethodReference
 		(SootToDexUtils.getDexClassName(t.getEnclosingClass()),
 		t.getEnclosingMethod(), typeList, returnTypeS);
	ImmutableMethodEncodedValue methodRef = new ImmutableMethodEncodedValue
			(dexFile.internMethodReference(mRef));
	AnnotationElement methodElement = new ImmutableAnnotationElement("value", methodRef);
	
	return new ImmutableAnnotation(AnnotationVisibility.SYSTEM,
			"Ldalvik/annotation/EnclosingMethod;",
			Collections.singleton(methodElement));
}
 

import org.jf.dexlib2.AnnotationVisibility; //导入依赖的package包/类
/**
 * Converts Jimple visibility to Dexlib visibility
 * 
 * @param visibility
 *            Jimple visibility
 * @return Dexlib visibility
 */
private static int getVisibility(int visibility) {
    if (visibility == AnnotationConstants.RUNTIME_VISIBLE)
        return AnnotationVisibility.RUNTIME;
    if (visibility == AnnotationConstants.RUNTIME_INVISIBLE)
        return AnnotationVisibility.SYSTEM;
    if (visibility == AnnotationConstants.SOURCE_VISIBLE)
        return AnnotationVisibility.BUILD;
    throw new RuntimeException("Unknown annotation visibility: '" + visibility + "'");
}
 

import org.jf.dexlib2.AnnotationVisibility; //导入依赖的package包/类
@Override
public int getVisibility() {
    return AnnotationVisibility.getVisibility("runtime");
}
 

import org.jf.dexlib2.AnnotationVisibility; //导入依赖的package包/类
private List<Annotation> buildInnerClassAttribute(SootClass parentClass,
 		InnerClassAttribute t, Set<String> skipList) {
 	if (t.getSpecs() == null)
 		return null;
 	
 	List<Annotation> anns = null;
 	for (Tag t2 : t.getSpecs()) {
 		InnerClassTag icTag = (InnerClassTag) t2;
 		
     	// In Dalvik, both the EnclosingMethod/EnclosingClass tag and the
     	// InnerClass tag are written to the inner class which is different
     	// to Java. We thus check whether this tag actually points to our
 		// outer class.
 		String outerClass = getOuterClassNameFromTag(icTag);
String innerClass = icTag.getInnerClass().replaceAll("/", ".");
			
// Only write the InnerClass tag to the inner class itself, not
// the other one. If the outer class points to our parent, but
// this is simply the wrong inner class, we also continue with the
// next tag.
 		if (!parentClass.hasOuterClass()
 				|| !innerClass.equals(parentClass.getName()))
 			continue;
 		
 		// If the outer class points to the very same class, we null it
 		if (parentClass.getName().equals(outerClass)
 				&& icTag.getOuterClass() == null)
 			outerClass = null;
 		
 		// Do not write garbage. Never.
 		if (parentClass.getName().equals(outerClass))
 			continue;
 		
 		// This is an actual inner class. Write the annotation
     	if (skipList.add("Ldalvik/annotation/InnerClass;")) {
  		// InnerClass annotation
      	List<AnnotationElement> elements = new ArrayList<AnnotationElement>();
   	
   	ImmutableAnnotationElement flagsElement = new ImmutableAnnotationElement
   			("accessFlags", new ImmutableIntEncodedValue(icTag.getAccessFlags()));
   	elements.add(flagsElement);
   	
   	ImmutableEncodedValue nameValue;
   	if (icTag.getShortName() != null && !icTag.getShortName().isEmpty())
   		nameValue = new ImmutableStringEncodedValue(icTag.getShortName());
   	else
   		nameValue = ImmutableNullEncodedValue.INSTANCE;
   	
   	ImmutableAnnotationElement nameElement = new ImmutableAnnotationElement
    		("name", nameValue);
    elements.add(nameElement);
   	
   	if (anns == null) anns = new ArrayList<Annotation>();
   	anns.add(new ImmutableAnnotation(AnnotationVisibility.SYSTEM,
   			"Ldalvik/annotation/InnerClass;",
   			elements));
     	}
 	}
 	    	
 	return anns;
 }
 

import org.jf.dexlib2.AnnotationVisibility; //导入依赖的package包/类
private List<Annotation> buildMemberClassesAttribute(SootClass parentClass,
 		InnerClassAttribute t, Set<String> skipList) {
 	List<Annotation> anns = null;
 	Set<String> memberClasses = null;
 	
 	// Collect the inner classes
 	for (Tag t2 : t.getSpecs()) {
 		InnerClassTag icTag = (InnerClassTag) t2;
 		String outerClass = getOuterClassNameFromTag(icTag);

// Only classes with names are member classes
if (icTag.getOuterClass() != null
		&& parentClass.getName().equals(outerClass)) {
	if (memberClasses == null)
		memberClasses = new HashSet<String>();
	memberClasses.add(SootToDexUtils.getDexClassName(icTag.getInnerClass()));
}
 	}
 	
 	// Write the member classes
 	if (memberClasses != null
 			&& !memberClasses.isEmpty()
 			&& skipList.add("Ldalvik/annotation/MemberClasses;")) {
     	List<EncodedValue> classes = new ArrayList<EncodedValue>();
  	for (String memberClass : memberClasses) {
  		ImmutableTypeEncodedValue classValue = new ImmutableTypeEncodedValue(memberClass);
  		classes.add(classValue);
  	}
  	
 		ImmutableArrayEncodedValue classesValue =
 				new ImmutableArrayEncodedValue(classes);
 		ImmutableAnnotationElement element =
 				new ImmutableAnnotationElement("value", classesValue);
  	ImmutableAnnotation memberAnnotation =
 				new ImmutableAnnotation(AnnotationVisibility.SYSTEM,
 						"Ldalvik/annotation/MemberClasses;",
 						Collections.singletonList(element));
  	if (anns == null) anns = new ArrayList<Annotation>();
  	anns.add(memberAnnotation);
 	}
 	return anns;
 }
 

import org.jf.dexlib2.AnnotationVisibility; //导入依赖的package包/类
/**
 * Converts Dexlib visibility to Jimple visibility.
 * 
 * In Dalvik:
 * VISIBILITY_BUILD   0x00 intended only to be visible at build time
 *                         (e.g., during compilation of other code)
 * VISIBILITY_RUNTIME 0x01 intended to visible at runtime
 * VISIBILITY_SYSTEM  0x02 intended to visible at runtime, but only to
 *                         the underlying system (and not to regular
 *                         user code)
 *
 * @param visibility
 *            Dexlib visibility
 * @return Jimple visibility
 */
private int getVisibility(int visibility) {
    if ("runtime".equals(AnnotationVisibility.getVisibility(visibility)))
        return AnnotationConstants.RUNTIME_VISIBLE;
    if ("system".equals(AnnotationVisibility.getVisibility(visibility)))
        return AnnotationConstants.RUNTIME_INVISIBLE;
    if ("build".equals(AnnotationVisibility.getVisibility(visibility)))//
        return AnnotationConstants.SOURCE_VISIBLE;
    throw new RuntimeException("error: unknown annotation visibility: '" + visibility + "'");
}