if (resolvedClass.isSubclassOf(CLASS_VIEW, false)) { if (!styleableName.equals(className)) { String message = String.format( context.report(ISSUE, node, context.getLocation(expression), message); } else if (resolvedClass.isSubclassOf(CLASS_VIEWGROUP + DOT_LAYOUT_PARAMS, false)) { ClassDeclaration outer = JavaContext.findSurroundingClass(cls.getParent()); if (outer == null) {
int depth = 0; while (cls != null) { List<VisitingDetector> list = mSuperClassDetectors.get(cls.getName()); if (list != null) { for (VisitingDetector v : list) { cls = cls.getSuperClass(); depth++; if (depth == 500) {
/** * @deprecated Use {@link JavaPsiScanner} APIs instead */ @Deprecated private static boolean haveSameCompilationUnit(@Nullable ResolvedClass cls1, @Nullable ResolvedClass cls2) { if (cls1 == null || cls2 == null) { return false; } //noinspection ConstantConditions while (cls1.getContainingClass() != null) { cls1 = cls1.getContainingClass(); } //noinspection ConstantConditions while (cls2.getContainingClass() != null) { cls2 = cls2.getContainingClass(); } return cls1.equals(cls2); }
String name = method.getContainingClass().getSimpleName() + "." + method.getName(); String message = getMissingPermissionMessage(requirement, name, permissions); context.report(MISSING_PERMISSION, node, context.getLocation(node), message);
ResolvedMethod method = (ResolvedMethod) resolved; JavaParser.ResolvedClass clz = method.getContainingClass(); if (clz.isSubclassOf("android.content.SharedPreferences.Editor", false) && mContext.getProject().getMinSdkVersion().getApiLevel() >= 9) {
"None of the methods in the added interface (%1$s) have been annotated " + "with `@android.webkit.JavascriptInterface`; they will not " + "be visible in API 17", cls.getSimpleName()); context.report(ISSUE, call, location, message);
cls.getName()); context.report(ISSUE, node, context.getLocation(node.astName()), message); return; if (cls.getContainingClass() != null && (flags & Modifier.STATIC) == 0) { String message = String.format( "This fragment inner class should be static (%1$s)", cls.getName()); context.report(ISSUE, node, context.getLocation(node.astName()), message); return; "This fragment should provide a default constructor (a public " + "constructor with no arguments) (`%1$s`)", cls.getName()); context.report(ISSUE, node, context.getLocation(node.astName()), message);
ResolvedClass containingClass = method.getContainingClass(); if ((OBTAIN.equals(name) || OBTAIN_NO_HISTORY.equals(name)) && containingClass.isSubclassOf(MOTION_EVENT_CLS, false)) { checkRecycled(context, node, MOTION_EVENT_CLS, RECYCLE); } else if (OBTAIN.equals(name) && containingClass.isSubclassOf(PARCEL_CLS, false)) { checkRecycled(context, node, PARCEL_CLS, RECYCLE); } else if (OBTAIN.equals(name) && containingClass.isSubclassOf(VELOCITY_TRACKER_CLS, false)) { checkRecycled(context, node, VELOCITY_TRACKER_CLS, RECYCLE); } else if ((OBTAIN_STYLED_ATTRIBUTES.equals(name) || OBTAIN_ATTRIBUTES.equals(name) || OBTAIN_TYPED_ARRAY.equals(name)) && (containingClass.isSubclassOf(CLASS_CONTEXT, false) || containingClass.isSubclassOf(RESOURCES_CLS, false))) { TypeDescriptor returnType = method.getReturnType(); if (returnType != null && returnType.matchesSignature(TYPED_ARRAY_CLS)) { checkRecycled(context, node, TYPED_ARRAY_CLS, RECYCLE); } else if (ACQUIRE_CPC.equals(name) && containingClass.isSubclassOf( CONTENT_RESOLVER_CLS, false)) { checkRecycled(context, node, CONTENT_PROVIDER_CLIENT_CLS, RELEASE); || QUERY_WITH_FACTORY.equals(name) || RAW_QUERY_WITH_FACTORY.equals(name)) && (containingClass.isSubclassOf(SQLITE_DATABASE_CLS, false) || containingClass.isSubclassOf(CONTENT_RESOLVER_CLS, false) || containingClass.isSubclassOf(CONTENT_PROVIDER_CLS, false) || containingClass.isSubclassOf(CONTENT_PROVIDER_CLIENT_CLS, false))) {
for (String methodName : methodNames) { boolean found = false; for (ResolvedMethod method : resolvedClass.getMethods(methodName, true)) { if (containingClass.matches(NOTIFICATION_LISTENER_SERVICE_FQN)) { continue;
if (!method.getContainingClass().isSubclassOf(CLASS_VIEW, false)) { return null; if (!method.getContainingClass().isSubclassOf( "android.support.wearable.watchface.WatchFaceService.Engine", false)) { return null;
ResolvedClass cls = getContainingClass().getSuperClass(); if (cls != null) { String methodName = getName(); int argCount = getArgumentCount(); for (ResolvedMethod method : cls.getMethods(methodName, true)) { if (argCount != method.getArgumentCount()) { continue;
for (ResolvedAnnotation annotation : cls.getAnnotations()) { String name = annotation.getSignature(); if (name.startsWith(SUPPORT_ANNOTATIONS_PREFIX) cls = cls.getSuperClass();
if (resolved instanceof ResolvedClass) { ResolvedClass cls = (ResolvedClass) resolved; ResolvedField field = cls.getField("CREATOR", false); if (field == null) { if (r instanceof ResolvedClass) { ResolvedClass parcelable = (ResolvedClass) r; if (!parcelable.isSubclassOf("android.os.Parcelable", false)) { return true;
ResolvedClass cls = resolvedClass; while (cls != null) { List<VisitingDetector> list = mSuperClassDetectors.get(cls.getName()); if (list != null) { for (VisitingDetector v : list) { cls = cls.getSuperClass();
if (clzz.isSubclassOf(sSupportSuperType[i], false)) { isSubClass = true; break;
if (!method.getContainingClass().isSubclassOf(CIPHER, false)) { return;
@Override public boolean visitConstructorInvocation(ConstructorInvocation node) { if (mVisitConstructors) { TypeReference typeReference = node.astTypeReference(); if (typeReference != null) { TypeReferencePart last = typeReference.astParts().last(); if (last != null) { String name = last.astIdentifier().astValue(); if (mConstructorSimpleNames.contains(name)) { ResolvedNode resolved = mContext.resolve(node); if (resolved instanceof ResolvedMethod) { ResolvedMethod method = (ResolvedMethod) resolved; String type = method.getContainingClass().getName(); List<VisitingDetector> list = mConstructorDetectors.get(type); if (list != null) { for (VisitingDetector v : list) { v.getJavaScanner().visitConstructor(mContext, v.getVisitor(), node, method); } } } } } } } return super.visitConstructorInvocation(node); } }
@Override protected boolean isCleanupCall(@NonNull MethodInvocation call) { String methodName = call.astName().astValue(); if (!recycleName.equals(methodName)) { return false; } ResolvedNode resolved = mContext.resolve(call); if (resolved instanceof ResolvedMethod) { ResolvedClass containingClass = ((ResolvedMethod) resolved).getContainingClass(); if (containingClass.isSubclassOf(recycleType, false)) { // Yes, called the right recycle() method; now make sure // we're calling it on the right variable Expression operand = call.astOperand(); if (operand != null) { resolved = mContext.resolve(operand); //noinspection SuspiciousMethodCalls if (resolved != null && mVariables.contains(resolved)) { return true; } } } } return false; } };
@Override public void visitMethod(@NonNull JavaContext context, @Nullable AstVisitor visitor, @NonNull MethodInvocation node) { // Ignore the issue if we never build for any API less than 17. if (context.getMainProject().getMinSdk() >= 17) { return; } // Ignore if the method doesn't fit our description. ResolvedNode resolved = context.resolve(node); if (!(resolved instanceof ResolvedMethod)) { return; } ResolvedMethod method = (ResolvedMethod) resolved; if (!method.getContainingClass().isSubclassOf(WEB_VIEW, false)) { return; } if (method.getArgumentCount() != 2 || !method.getArgumentType(0).matchesName(TYPE_OBJECT) || !method.getArgumentType(1).matchesName(TYPE_STRING)) { return; } String message = "`WebView.addJavascriptInterface` should not be called with minSdkVersion < 17 for security reasons: " + "JavaScript can use reflection to manipulate application"; context.report(ISSUE, node, context.getLocation(node.astName()), message); } }
/** * Returns true if the given method invocation node corresponds to a call on a * {@code android.content.Context} * * @param node the method call node * @return true iff the method call is on a class extending context * @deprecated use {@link JavaEvaluator#isMemberInSubClassOf(PsiMember, String, boolean)} instead */ @Deprecated public boolean isContextMethod(@NonNull MethodInvocation node) { // Method name used in many other contexts where it doesn't have the // same semantics; only use this one if we can resolve types // and we're certain this is the Context method ResolvedNode resolved = resolve(node); if (resolved instanceof JavaParser.ResolvedMethod) { JavaParser.ResolvedMethod method = (JavaParser.ResolvedMethod) resolved; ResolvedClass containingClass = method.getContainingClass(); if (containingClass.isSubclassOf(CLASS_CONTEXT, false)) { return true; } } return false; }