Java JavaContext.resolve方法代码示例

import com.android.tools.lint.detector.api.JavaContext; //导入方法依赖的package包/类
private static boolean isAddReplaceOpen(@NonNull JavaContext context, @NonNull MethodInvocation node) {
    String methodName = node.astName().astValue();

    if (ADD_TRANSACTION.equals(methodName) || OPEN_TRANSACTION.equals(methodName) || REPLACE_TRANSACTION.equals(methodName)) {
        JavaParser.ResolvedNode resolved = context.resolve(node);
        if (resolved instanceof JavaParser.ResolvedMethod) {
            JavaParser.ResolvedMethod method = (JavaParser.ResolvedMethod) resolved;
            JavaParser.ResolvedClass containingClass = method.getContainingClass();
            if (containingClass.isSubclassOf(ACTIVITY_MANAGER, false)) {
                return true;
            }
        }
    }

    return false;
}
 

import com.android.tools.lint.detector.api.JavaContext; //导入方法依赖的package包/类
@Override
public AstVisitor createJavaVisitor(final JavaContext context) {
    return new ForwardingAstVisitor() {
        @Override
        public boolean visitMethodInvocation(MethodInvocation node) {
            JavaParser.ResolvedNode resolve = context.resolve(node);
            if (resolve instanceof JavaParser.ResolvedMethod) {
                JavaParser.ResolvedMethod method = (JavaParser.ResolvedMethod) resolve;
                // 方法所在的类校验
                JavaParser.ResolvedClass containingClass = method.getContainingClass();
                if (containingClass.matches("android.util.Log")) {
                    context.report(ISSUE, node, context.getLocation(node),
                                   "请使用Ln，避免使用Log");
                    return true;
                }
                if (node.toString().startsWith("System.out.println")) {
                    context.report(ISSUE, node, context.getLocation(node),
                                   "请使用Ln，避免使用System.out.println");
                    return true;
                }
            }
            return super.visitMethodInvocation(node);
        }
    };
}
 

import com.android.tools.lint.detector.api.JavaContext; //导入方法依赖的package包/类
public static JavaParser.ResolvedMethod parseResolvedMethod(
        @NonNull JavaContext context, @NonNull Node node) {
    if (null == context || null == node) {
        return null;
    }

    JavaParser.ResolvedNode resolvedNode = null;
    try {
        resolvedNode = context.resolve(node);
    } catch (Exception e) {
        // TODO
    }

    return (resolvedNode instanceof JavaParser.ResolvedMethod) ?
            (JavaParser.ResolvedMethod)resolvedNode : null;
}
 

import com.android.tools.lint.detector.api.JavaContext; //导入方法依赖的package包/类
/**
 * If setContentView is called by 'this' instance,
 * this method will check if 'this' is an instance of a Class inherit from android.app.Activity, for eaxmple AppCompatActivity or FragmentActivity, and so on.
 */
private boolean isThisInstanceOfActivity_ForActivity(@NonNull JavaContext context, @NonNull MethodInvocation node) {
    Node currentNode = node.getParent();

    JavaParser.ResolvedNode resolved = context.resolve(JavaContext.findSurroundingClass(node));
    JavaParser.ResolvedClass sorroundingClass = (JavaParser.ResolvedClass) resolved;
    while (sorroundingClass != null) {
        //System.out.println("sorroundingClass = " + sorroundingClass);
        if ("android.app.Activity".equals(sorroundingClass.getName())) {
            return true;
        } else {
            sorroundingClass = sorroundingClass.getSuperClass();
        }
    }


    return false;


}
 

import com.android.tools.lint.detector.api.JavaContext; //导入方法依赖的package包/类
/**
 * As there are more than one methods overload "setContentView",
 * we have to identify the one we want to check, whose param has an Annotation of "@LayoutRes".
 * In fact, {public void setContentView(@LayoutRes int layoutResID)} is the one we are looking for.
 */
private boolean isThisMethodHasLayoutAnnotation_ForActivity(@NonNull JavaContext context, @NonNull MethodInvocation node) {
    JavaParser.ResolvedNode resolved = context.resolve(node);
    JavaParser.ResolvedMethod method = (JavaParser.ResolvedMethod) resolved;

    if (node.astArguments().size() != 1) {
        return false;
    }

    Iterable<JavaParser.ResolvedAnnotation> annotations = method.getParameterAnnotations(0);
    for (JavaParser.ResolvedAnnotation annotation : annotations) {
        if ("android.support.annotation.LayoutRes".equals(annotation.getName())) {
            return true;
        }
    }

    return false;

}
 

import com.android.tools.lint.detector.api.JavaContext; //导入方法依赖的package包/类
private static boolean isAppBarActivityCall(@NonNull JavaContext context,
        @NonNull MethodInvocation node) {
    ResolvedNode resolved = context.resolve(node);
    if (resolved instanceof ResolvedMethod) {
        ResolvedMethod method = (ResolvedMethod) resolved;
        ResolvedClass containingClass = method.getContainingClass();
        if (containingClass.isSubclassOf(CLASS_ACTIVITY, false)) {
            // Make sure that the calling context is a subclass of ActionBarActivity;
            // we don't want to flag these calls if they are in non-appcompat activities
            // such as PreferenceActivity (see b.android.com/58512)
            ClassDeclaration surroundingClass = JavaContext.findSurroundingClass(node);
            if (surroundingClass != null) {
                ResolvedNode clz = context.resolve(surroundingClass);
                return clz instanceof ResolvedClass &&
                        ((ResolvedClass)clz).isSubclassOf(
                                "android.support.v7.app.ActionBarActivity",
                                false);
            }
        }
    }
    return false;
}
 

import com.android.tools.lint.detector.api.JavaContext; //导入方法依赖的package包/类
/**
 * There are more than one methods overloading in the name of "inflate()" in android.view.LayoutInflater.<br>
 * We only care about those having an param with `@LayoutRes` annotation,
 * for example {public View inflate(@LayoutRes int resource, @Nullable ViewGroup root, boolean attachToRoot)}.<br>
 * This method will find out the resource param with an `@LayoutRes` annotation in String format, for example `R.layout.fragment_blank` .<br>
 * If no such param exists, <B>null</B> will be returned.
 */
private String getParamWithLayoutAnnotation_ForFragment(@NonNull JavaContext context, @NonNull MethodInvocation node) {
    Iterator<Expression> arguments = node.astArguments().iterator();
    Expression argument = arguments.next();

    JavaParser.ResolvedNode resolved = context.resolve(node);
    JavaParser.ResolvedMethod method = (JavaParser.ResolvedMethod) resolved;

    JavaParser.ResolvedAnnotation layoutParamAnnotation = method.getParameterAnnotation("android.support.annotation.LayoutRes", 0);
    if (layoutParamAnnotation != null) {
        return argument.toString();
    } else {
        return null;
    }

}
 

import com.android.tools.lint.detector.api.JavaContext; //导入方法依赖的package包/类
@Override
public void visitMethod(@NonNull JavaContext context, AstVisitor visitor, @NonNull MethodInvocation node) {
    JavaParser.ResolvedClass sorroundingClass = (JavaParser.ResolvedClass)context.resolve(JavaContext.findSurroundingClass(node));
    JavaParser.ResolvedMethod sorroundingMethod = (JavaParser.ResolvedMethod)context.resolve(JavaContext.findSurroundingMethod(node));

    if (sorroundingMethod.getName().equals("onCreateViewHolder")
            && sorroundingClass.isSubclassOf("android.support.v7.widget.RecyclerView.Adapter", false)){


        String layoutString = getParamWithLayoutAnnotation(context, node);
        if (layoutString == null){
            return;
        }

        if (!isFileStringStartWithPrefix(layoutString, "item_")) {
            context.report(ISSUE,
                    node,
                    context.getLocation(node),
                    "Layout resource file in ViewHolder must be named with prefix `item_`.");
        }

    }


}
 

import com.android.tools.lint.detector.api.JavaContext; //导入方法依赖的package包/类
/**
 * There are more than one methods overloading in the name of "inflate()" in android.view.LayoutInflater.<br>
 * We only care about those having an param with `@LayoutRes` annotation,
 * for example {public View inflate(@LayoutRes int resource, @Nullable ViewGroup root, boolean attachToRoot)}.<br>
 * This method will find out the resource param with an `@LayoutRes` annotation in String format, for example `R.layout.fragment_blank` .<br>
 * If no such param exists, <B>null</B> will be returned.
 */
private String getParamWithLayoutAnnotation(@NonNull JavaContext context, @NonNull MethodInvocation node) {
    Iterator<Expression> arguments = node.astArguments().iterator();
    Expression argument = arguments.next();

    JavaParser.ResolvedNode resolved = context.resolve(node);
    JavaParser.ResolvedMethod method = (JavaParser.ResolvedMethod) resolved;

    JavaParser.ResolvedAnnotation layoutParamAnnotation = method.getParameterAnnotation("android.support.annotation.LayoutRes", 0);
    if (layoutParamAnnotation != null) {
        return argument.toString();
    } else {
        return null;
    }

}
 

import com.android.tools.lint.detector.api.JavaContext; //导入方法依赖的package包/类
private static void report(JavaContext context, MethodInvocation node) {
    // Make sure the call is on a view
    JavaParser.ResolvedNode resolved = context.resolve(node);
    if (resolved instanceof JavaParser.ResolvedMethod) {
        JavaParser.ResolvedMethod method = (JavaParser.ResolvedMethod) resolved;
        JavaParser.ResolvedClass containingClass = method.getContainingClass();
        if (!containingClass.isSubclassOf(CLASS_VIEW, false)) {
            return;
        }
    }

    String name = node.astName().astValue();
    String suggestion = Character.toLowerCase(name.charAt(2)) + name.substring(3);
    String message = String.format(
            // Keep in sync with {@link #getOldValue} and {@link #getNewValue} below!
            "Suspicious method call; should probably call \"`%1$s`\" rather than \"`%2$s`\"",
            suggestion, name);
    context.report(ISSUE, node, context.getLocation(node.astName()), message);
}
 

import com.android.tools.lint.detector.api.JavaContext; //导入方法依赖的package包/类
@NonNull
private static PermissionHolder addLocalPermissions(
        @NonNull JavaContext context,
        @NonNull PermissionHolder permissions,
        @NonNull Node node) {
    // Accumulate @RequirePermissions available in the local context
    Node methodNode = JavaContext.findSurroundingMethod(node);
    if (methodNode == null) {
        return permissions;
    }
    ResolvedNode resolved = context.resolve(methodNode);
    if (!(resolved instanceof ResolvedMethod)) {
        return permissions;
    }
    ResolvedMethod method = (ResolvedMethod) resolved;
    ResolvedAnnotation annotation = method.getAnnotation(PERMISSION_ANNOTATION);
    permissions = mergeAnnotationPermissions(context, permissions, annotation);
    annotation = method.getContainingClass().getAnnotation(PERMISSION_ANNOTATION);
    permissions = mergeAnnotationPermissions(context, permissions, annotation);
    return permissions;
}
 

import com.android.tools.lint.detector.api.JavaContext; //导入方法依赖的package包/类
@Override
public void visitMethod(@NonNull JavaContext context, @Nullable AstVisitor visitor,
        @NonNull MethodInvocation node) {
    ResolvedNode resolved = context.resolve(node);

    if (!(resolved instanceof ResolvedMethod) ||
            !((ResolvedMethod) resolved).getContainingClass()
                    .isSubclassOf(PACKAGE_MANAGER_CLASS, false)) {
        return;
    }
    StrictListAccessor<Expression, MethodInvocation> argumentList = node.astArguments();

    // Ignore if the method doesn't fit our description.
    if (argumentList != null && argumentList.size() == 2) {
        TypeDescriptor firstParameterType = context.getType(argumentList.first());
        if (firstParameterType != null
            && firstParameterType.matchesSignature(JavaParser.TYPE_STRING)) {
            maybeReportIssue(calculateValue(context, argumentList.last()), context, node);
        }
    }
}
 

import com.android.tools.lint.detector.api.JavaContext; //导入方法依赖的package包/类
private static boolean isStringParameter(
        @NonNull Expression expression, @NonNull JavaContext context) {
    if (expression instanceof StringLiteral) {
        return true;
    } else {
        ResolvedNode resolvedNode = context.resolve(expression);
        if (resolvedNode instanceof ResolvedField) {
            if (((ResolvedField) resolvedNode).getValue() instanceof String) {
                return true;
            }
        }
    }
    return false;
}
 

import com.android.tools.lint.detector.api.JavaContext; //导入方法依赖的package包/类
private boolean isInsideDialogFragment(JavaContext context, MethodInvocation node) {
    Node parent = node.getParent();
    while (parent != null) {
        Object resolvedNode = context.resolve(parent);
        if (resolvedNode instanceof JavaParser.ResolvedMethod) {
            JavaParser.ResolvedMethod method = (JavaParser.ResolvedMethod) resolvedNode;
            if (isDialogFragment(method.getContainingClass())) {
                return true;
            }
        }
        parent = parent.getParent();
    }
    return false;
}
 

import com.android.tools.lint.detector.api.JavaContext; //导入方法依赖的package包/类
private static boolean isMethodOnFragmentClass(
        @NonNull JavaContext context,
        @NonNull MethodInvocation call,
        @NonNull String fragmentClass,
        @NonNull String v4FragmentClass) {
    ResolvedNode resolved = context.resolve(call);
    if (resolved instanceof ResolvedMethod) {
        ResolvedClass containingClass = ((ResolvedMethod) resolved).getContainingClass();
        return containingClass.isSubclassOf(fragmentClass, false) ||
                containingClass.isSubclassOf(v4FragmentClass, false);
    }

    return false;
}