Java JavaParser.ResolvedClass方法代码示例

import com.android.tools.lint.client.api.JavaParser; //导入方法依赖的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.client.api.JavaParser; //导入方法依赖的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.client.api.JavaParser; //导入方法依赖的package包/类
@Override
public boolean visitMethodInvocation(MethodInvocation node) {
    JavaParser.ResolvedMethod resolvedMethod = NodeUtils.parseResolvedMethod(mContext, node);
    if (null == resolvedMethod) {
        return super.visitMethodInvocation(node);
    }

    // The containing class must be subclass of android.app.ActivityManager
    JavaParser.ResolvedClass resolvedClass = resolvedMethod.getContainingClass();
    if (!resolvedClass.isSubclassOf("android.app.ActivityManager", false)) {
        return super.visitMethodInvocation(node);
    }

    // Only handle ActivityManager.getRunningAppProcesses()
    if (!getRunningAppProcesses_SIGNATURE.equals(resolvedMethod.getSignature())) {
        return super.visitMethodInvocation(node);
    }

    mContext.report(
            GetRunningAppProcessesDetector.ISSUE,
            mContext.getLocation(node),
            "Please DO NOT invoke ActivityManager.getRunningAppProcesses(), since it may cause performance issue and not applicable in Android 5.1+ .");

    return super.visitMethodInvocation(node);
}
 

import com.android.tools.lint.client.api.JavaParser; //导入方法依赖的package包/类
@Override
public boolean visitConstructorInvocation(ConstructorInvocation node) {
    JavaParser.ResolvedNode resolvedType = mContext.resolve(node.astTypeReference());
    JavaParser.ResolvedClass resolvedClass = (JavaParser.ResolvedClass) resolvedType;

    if (resolvedClass != null
            && resolvedClass.isSubclassOf("android.os.Message", false)){
        mContext.report(ISSUE,
                node,
                mContext.getLocation(node),
                "You should not call `new Message()` directly.");

        return true;

    }

    return super.visitConstructorInvocation(node);
}
 

import com.android.tools.lint.client.api.JavaParser; //导入方法依赖的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.client.api.JavaParser; //导入方法依赖的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.client.api.JavaParser; //导入方法依赖的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.client.api.JavaParser; //导入方法依赖的package包/类
@Override
public void checkClass(@NonNull JavaContext context, @Nullable ClassDeclaration declaration,
        @NonNull Node node, @NonNull JavaParser.ResolvedClass resolvedClass) {
    String className = resolvedClass.getName();
    if (mWrapperClasses.contains(className)) {
        return; // ignore the wrapper classes
    }

    JavaParser.ResolvedClass superClass = resolvedClass.getSuperClass();
    String superClassName = superClass.getName();
    while (!mWrapperClasses.contains(superClassName)) {
        if (mTargetClasses.contains(superClassName)) {
            Node locationNode = node instanceof ClassDeclaration
                    ? ((ClassDeclaration) node).astName() : node;
            reportViolation(context, locationNode);
            break;
        }
        superClass = superClass.getSuperClass();
        superClassName = superClass.getName();
    }
}
 

import com.android.tools.lint.client.api.JavaParser; //导入方法依赖的package包/类
private boolean checkRuleViolation(JavaContext context, MethodInvocation node) {
    JavaParser.ResolvedMethod method = (JavaParser.ResolvedMethod) context.resolve(node);
    JavaParser.ResolvedClass containingClass = method.getContainingClass();
    String containingClassName = containingClass.getName();
    if (mWrapperClassName.equals(containingClassName)) {
        return false;
    }

    for (String targetClassName : mTargetClassNames) {
        if (targetClassName.equals(containingClassName)) {
            return true;
        }
        if (containingClass.isSubclassOf(targetClassName, false)) {
            return true;
        }
    }
    return false;
}
 

import com.android.tools.lint.client.api.JavaParser; //导入方法依赖的package包/类
private boolean isDialogFragment(JavaParser.ResolvedClass clazz) {
    JavaParser.ResolvedClass superClazz = clazz;
    while (superClazz != null) {
        String name = superClazz.getName();
        if (DIALOG_FRAGMENT.equals(name) || V4_DIALOG_FRAGMENT.equals(name)) {
            return true;
        }
        superClazz = superClazz.getSuperClass();
    }
    return false;
}
 

import com.android.tools.lint.client.api.JavaParser; //导入方法依赖的package包/类
public static JavaParser.ResolvedClass parseContainingClass(
        @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
    }

    if (resolvedNode instanceof JavaParser.ResolvedMethod) {
        return ((JavaParser.ResolvedMethod)resolvedNode).getContainingClass();
    } else if (resolvedNode instanceof JavaParser.ResolvedField) {
        return ((JavaParser.ResolvedField)resolvedNode).getContainingClass();
    } else if (resolvedNode instanceof JavaParser.ResolvedClass) {
        return ((JavaParser.ResolvedClass)resolvedNode).getContainingClass();
    } else {
        ClassDeclaration classDeclaration = JavaContext.findSurroundingClass(node);
        if (null == classDeclaration) {
            return null;
        }
        resolvedNode = context.resolve(classDeclaration);
        return (resolvedNode instanceof JavaParser.ResolvedClass) ?
                (JavaParser.ResolvedClass)resolvedNode : null;
    }
}
 

import com.android.tools.lint.client.api.JavaParser; //导入方法依赖的package包/类
private void printMissingMethod(MethodDeclaration node) {
    // Ignore constructor
    if (null == node.astReturnTypeReference()) {
        return;
    }

    // Only public/protected methods
    Modifiers modifiers = node.astModifiers();
    if (null == modifiers ||
            (!modifiers.isPublic() && !modifiers.isProtected())) {
        return;
    }

    JavaParser.ResolvedMethod resolvedMethod = NodeUtils.parseResolvedMethod(mContext, node);
    if (null == resolvedMethod) {
        return;
    }

    JavaParser.ResolvedClass resolvedClass = resolvedMethod.getContainingClass();
    if (null == resolvedClass || !isInAndroidSdk(resolvedClass)) {
        return;
    }

    if (isRemoved(node)) {
        appendMethod(removedMethods, resolvedClass.getName(), resolvedMethod.getSignature());
    }
    if (isHide(node)) {
        appendMethod(hideMethods, resolvedClass.getName(), resolvedMethod.getSignature());
    }
}
 

import com.android.tools.lint.client.api.JavaParser; //导入方法依赖的package包/类
private boolean isInAndroidSdk(JavaParser.ResolvedClass clazz) {
    for (String androidPackage : ANDROID_PACKAGES) {
        if (clazz.isInPackage(androidPackage, true)) {
            return true;
        }
    }
    return false;
}
 

import com.android.tools.lint.client.api.JavaParser; //导入方法依赖的package包/类
@Override
public boolean visitConstructorInvocation(ConstructorInvocation node) {
    Node containingMethod = JavaContext.findSurroundingMethod(node);
    if (null == containingMethod) {
        return super.visitConstructorInvocation(node);
    }

    JavaParser.ResolvedMethod resolvedMethod = NodeUtils.parseResolvedMethod(mContext, containingMethod);
    if (null == resolvedMethod) {
        return super.visitConstructorInvocation(node);
    }
    JavaParser.ResolvedClass resolvedClass = resolvedMethod.getContainingClass();
    if (null == resolvedClass) {
        return super.visitConstructorInvocation(node);
    }

    for (String observedClass : OBSERVED_METHODS.keySet()) {
        if (resolvedClass.isSubclassOf(observedClass, false) &&
                OBSERVED_METHODS.get(observedClass).contains(resolvedMethod.getName())) {
            mContext.report(
                    WrongAllocationDetector.ISSUE,
                    mContext.getLocation(node),
                    String.format("Please don't create new objects in %s : %s", resolvedClass.getName(), resolvedMethod.getName())
            );
        }
    }

    return super.visitConstructorInvocation(node);
}
 

import com.android.tools.lint.client.api.JavaParser; //导入方法依赖的package包/类
@Override
public boolean visitConstructorInvocation(ConstructorInvocation node) {
    JavaParser.ResolvedClass typeClass = NodeUtils.parseContainingClass(mContext, node);
    if (null != typeClass &&
            typeClass.isSubclassOf("android.os.Message", false)) {
        mContext.report(
                NewMessageDetector.ISSUE,
                mContext.getLocation(node),
                "Please use Message.obtain() instead of new Message()"
        );
    }

    return super.visitConstructorInvocation(node);
}