Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
com.android.tools.lint.checks.CleanupDetector Maven / Gradle / Ivy
/*
* Copyright (C) 2012 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.tools.lint.checks;
import static com.android.SdkConstants.CLASS_CONTEXT;
import com.android.annotations.NonNull;
import com.android.annotations.Nullable;
import com.android.tools.lint.client.api.JavaParser.ResolvedClass;
import com.android.tools.lint.client.api.JavaParser.ResolvedField;
import com.android.tools.lint.client.api.JavaParser.ResolvedMethod;
import com.android.tools.lint.client.api.JavaParser.ResolvedNode;
import com.android.tools.lint.client.api.JavaParser.ResolvedVariable;
import com.android.tools.lint.client.api.JavaParser.TypeDescriptor;
import com.android.tools.lint.detector.api.Category;
import com.android.tools.lint.detector.api.Detector;
import com.android.tools.lint.detector.api.Detector.JavaScanner;
import com.android.tools.lint.detector.api.Implementation;
import com.android.tools.lint.detector.api.Issue;
import com.android.tools.lint.detector.api.JavaContext;
import com.android.tools.lint.detector.api.Location;
import com.android.tools.lint.detector.api.Scope;
import com.android.tools.lint.detector.api.Severity;
import com.google.common.collect.Lists;
import java.util.Arrays;
import java.util.List;
import lombok.ast.AstVisitor;
import lombok.ast.BinaryExpression;
import lombok.ast.BinaryOperator;
import lombok.ast.ConstructorInvocation;
import lombok.ast.Expression;
import lombok.ast.ForwardingAstVisitor;
import lombok.ast.MethodInvocation;
import lombok.ast.Node;
import lombok.ast.Return;
import lombok.ast.StrictListAccessor;
import lombok.ast.VariableDefinitionEntry;
import lombok.ast.VariableReference;
/**
* Checks for missing {@code recycle} calls on resources that encourage it, and
* for missing {@code commit} calls on FragmentTransactions, etc.
*/
public class CleanupDetector extends Detector implements JavaScanner {
private static final Implementation IMPLEMENTATION = new Implementation(
CleanupDetector.class,
Scope.JAVA_FILE_SCOPE);
/** Problems with missing recycle calls */
public static final Issue RECYCLE_RESOURCE = Issue.create(
"Recycle", //$NON-NLS-1$
"Missing `recycle()` calls",
"Many resources, such as TypedArrays, VelocityTrackers, etc., " +
"should be recycled (with a `recycle()` call) after use. This lint check looks " +
"for missing `recycle()` calls.",
Category.PERFORMANCE,
7,
Severity.WARNING,
IMPLEMENTATION);
/** Problems with missing commit calls. */
public static final Issue COMMIT_FRAGMENT = Issue.create(
"CommitTransaction", //$NON-NLS-1$
"Missing `commit()` calls",
"After creating a `FragmentTransaction`, you typically need to commit it as well",
Category.CORRECTNESS,
7,
Severity.WARNING,
IMPLEMENTATION);
// Target method names
private static final String RECYCLE = "recycle"; //$NON-NLS-1$
private static final String RELEASE = "release"; //$NON-NLS-1$
private static final String OBTAIN = "obtain"; //$NON-NLS-1$
private static final String SHOW = "show"; //$NON-NLS-1$
private static final String ACQUIRE_CPC = "acquireContentProviderClient"; //$NON-NLS-1$
private static final String OBTAIN_NO_HISTORY = "obtainNoHistory"; //$NON-NLS-1$
private static final String OBTAIN_ATTRIBUTES = "obtainAttributes"; //$NON-NLS-1$
private static final String OBTAIN_TYPED_ARRAY = "obtainTypedArray"; //$NON-NLS-1$
private static final String OBTAIN_STYLED_ATTRIBUTES = "obtainStyledAttributes"; //$NON-NLS-1$
private static final String BEGIN_TRANSACTION = "beginTransaction"; //$NON-NLS-1$
private static final String COMMIT = "commit"; //$NON-NLS-1$
private static final String COMMIT_ALLOWING_LOSS = "commitAllowingStateLoss"; //$NON-NLS-1$
private static final String QUERY = "query"; //$NON-NLS-1$
private static final String RAW_QUERY = "rawQuery"; //$NON-NLS-1$
private static final String QUERY_WITH_FACTORY = "queryWithFactory"; //$NON-NLS-1$
private static final String RAW_QUERY_WITH_FACTORY = "rawQueryWithFactory"; //$NON-NLS-1$
private static final String CLOSE = "close"; //$NON-NLS-1$
private static final String MOTION_EVENT_CLS = "android.view.MotionEvent"; //$NON-NLS-1$
private static final String RESOURCES_CLS = "android.content.res.Resources"; //$NON-NLS-1$
private static final String PARCEL_CLS = "android.os.Parcel"; //$NON-NLS-1$
private static final String TYPED_ARRAY_CLS = "android.content.res.TypedArray"; //$NON-NLS-1$
private static final String VELOCITY_TRACKER_CLS = "android.view.VelocityTracker";//$NON-NLS-1$
private static final String DIALOG_FRAGMENT = "android.app.DialogFragment"; //$NON-NLS-1$
private static final String DIALOG_V4_FRAGMENT =
"android.support.v4.app.DialogFragment"; //$NON-NLS-1$
private static final String FRAGMENT_MANAGER_CLS = "android.app.FragmentManager"; //$NON-NLS-1$
private static final String FRAGMENT_MANAGER_V4_CLS =
"android.support.v4.app.FragmentManager"; //$NON-NLS-1$
private static final String FRAGMENT_TRANSACTION_CLS =
"android.app.FragmentTransaction"; //$NON-NLS-1$
private static final String FRAGMENT_TRANSACTION_V4_CLS =
"android.support.v4.app.FragmentTransaction"; //$NON-NLS-1$
public static final String SURFACE_CLS = "android.view.Surface";
public static final String SURFACE_TEXTURE_CLS = "android.graphics.SurfaceTexture";
public static final String CONTENT_PROVIDER_CLIENT_CLS
= "android.content.ContentProviderClient";
public static final String CONTENT_RESOLVER_CLS = "android.content.ContentResolver";
public static final String CONTENT_PROVIDER_CLS = "android.content.ContentProvider";
@SuppressWarnings("SpellCheckingInspection")
public static final String SQLITE_DATABASE_CLS = "android.database.sqlite.SQLiteDatabase";
public static final String CURSOR_CLS = "android.database.Cursor";
/** Constructs a new {@link CleanupDetector} */
public CleanupDetector() {
}
// ---- Implements JavaScanner ----
@Nullable
@Override
public List getApplicableMethodNames() {
return Arrays.asList(
// FragmentManager commit check
BEGIN_TRANSACTION,
// Recycle check
OBTAIN, OBTAIN_NO_HISTORY,
OBTAIN_STYLED_ATTRIBUTES,
OBTAIN_ATTRIBUTES,
OBTAIN_TYPED_ARRAY,
// Release check
ACQUIRE_CPC,
// Cursor close check
QUERY, RAW_QUERY, QUERY_WITH_FACTORY, RAW_QUERY_WITH_FACTORY
);
}
@Nullable
@Override
public List getApplicableConstructorTypes() {
return Arrays.asList(SURFACE_TEXTURE_CLS, SURFACE_CLS);
}
@Override
public void visitMethod(@NonNull JavaContext context, @Nullable AstVisitor visitor,
@NonNull MethodInvocation node) {
String name = node.astName().astValue();
if (BEGIN_TRANSACTION.equals(name)) {
checkTransactionCommits(context, node);
} else {
checkResourceRecycled(context, node, name);
}
}
@Override
public void visitConstructor(@NonNull JavaContext context, @Nullable AstVisitor visitor,
@NonNull ConstructorInvocation node, @NonNull ResolvedMethod constructor) {
checkRecycled(context, node, constructor.getContainingClass().getSignature(), RELEASE);
}
private static void checkResourceRecycled(@NonNull JavaContext context,
@NonNull MethodInvocation node, @NonNull String name) {
// Recycle detector
ResolvedNode resolved = context.resolve(node);
if (!(resolved instanceof ResolvedMethod)) {
return;
}
ResolvedMethod method = (ResolvedMethod) resolved;
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);
} else if ((QUERY.equals(name)
|| RAW_QUERY.equals(name)
|| 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))) {
// Other potential cursors-returning methods that should be tracked:
// android.app.DownloadManager#query
// android.content.ContentProviderClient#query
// android.content.ContentResolver#query
// android.database.sqlite.SQLiteQueryBuilder#query
// android.provider.Browser#getAllBookmarks
// android.provider.Browser#getAllVisitedUrls
// android.provider.DocumentsProvider#queryChildDocuments
// android.provider.DocumentsProvider#qqueryDocument
// android.provider.DocumentsProvider#queryRecentDocuments
// android.provider.DocumentsProvider#queryRoots
// android.provider.DocumentsProvider#querySearchDocuments
// android.provider.MediaStore$Images$Media#query
// android.widget.FilterQueryProvider#runQuery
checkRecycled(context, node, CURSOR_CLS, CLOSE);
}
}
private static void checkRecycled(@NonNull final JavaContext context, @NonNull Node node,
@NonNull final String recycleType, @NonNull final String recycleName) {
ResolvedVariable boundVariable = getVariable(context, node);
if (boundVariable == null) {
return;
}
Node method = JavaContext.findSurroundingMethod(node);
if (method == null) {
return;
}
FinishVisitor visitor = new FinishVisitor(context, boundVariable) {
@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;
}
};
method.accept(visitor);
if (visitor.isCleanedUp() || visitor.variableEscapes()) {
return;
}
String className = recycleType.substring(recycleType.lastIndexOf('.') + 1);
String message;
if (RECYCLE.equals(recycleName)) {
message = String.format(
"This `%1$s` should be recycled after use with `#recycle()`", className);
} else {
message = String.format(
"This `%1$s` should be freed up after use with `#%2$s()`", className,
recycleName);
}
Node locationNode = node instanceof MethodInvocation ?
((MethodInvocation) node).astName() : node;
Location location = context.getLocation(locationNode);
context.report(RECYCLE_RESOURCE, node, location, message);
}
private static boolean checkTransactionCommits(@NonNull JavaContext context,
@NonNull MethodInvocation node) {
if (isBeginTransaction(context, node)) {
ResolvedVariable boundVariable = getVariable(context, node);
if (boundVariable == null && isCommittedInChainedCalls(context, node)) {
return true;
}
if (boundVariable != null) {
Node method = JavaContext.findSurroundingMethod(node);
if (method == null) {
return true;
}
FinishVisitor commitVisitor = new FinishVisitor(context, boundVariable) {
@Override
protected boolean isCleanupCall(@NonNull MethodInvocation call) {
if (isTransactionCommitMethodCall(mContext, call)) {
Expression operand = call.astOperand();
if (operand != null) {
ResolvedNode resolved = mContext.resolve(operand);
//noinspection SuspiciousMethodCalls
if (resolved != null && mVariables.contains(resolved)) {
return true;
} else if (resolved instanceof ResolvedMethod
&& operand instanceof MethodInvocation
&& isCommittedInChainedCalls(mContext,(MethodInvocation) operand)) {
// Check that the target of the committed chains is the
// right variable!
while (operand instanceof MethodInvocation) {
operand = ((MethodInvocation)operand).astOperand();
}
if (operand instanceof VariableReference) {
resolved = mContext.resolve(operand);
//noinspection SuspiciousMethodCalls
if (resolved != null && mVariables.contains(resolved)) {
return true;
}
}
}
}
} else if (isShowFragmentMethodCall(mContext, call)) {
StrictListAccessor arguments =
call.astArguments();
if (arguments.size() == 2) {
Expression first = arguments.first();
ResolvedNode resolved = mContext.resolve(first);
//noinspection SuspiciousMethodCalls
if (resolved != null && mVariables.contains(resolved)) {
return true;
}
}
}
return false;
}
};
method.accept(commitVisitor);
if (commitVisitor.isCleanedUp() || commitVisitor.variableEscapes()) {
return true;
}
}
String message = "This transaction should be completed with a `commit()` call";
context.report(COMMIT_FRAGMENT, node, context.getLocation(node.astName()),
message);
}
return false;
}
private static boolean isCommittedInChainedCalls(@NonNull JavaContext context,
@NonNull MethodInvocation node) {
// Look for chained calls since the FragmentManager methods all return "this"
// to allow constructor chaining, e.g.
// getFragmentManager().beginTransaction().addToBackStack("test")
// .disallowAddToBackStack().hide(mFragment2).setBreadCrumbShortTitle("test")
// .show(mFragment2).setCustomAnimations(0, 0).commit();
Node parent = node.getParent();
while (parent instanceof MethodInvocation) {
MethodInvocation methodInvocation = (MethodInvocation) parent;
if (isTransactionCommitMethodCall(context, methodInvocation)
|| isShowFragmentMethodCall(context, methodInvocation)) {
return true;
}
parent = parent.getParent();
}
return false;
}
private static boolean isTransactionCommitMethodCall(@NonNull JavaContext context,
@NonNull MethodInvocation call) {
String methodName = call.astName().astValue();
return (COMMIT.equals(methodName) || COMMIT_ALLOWING_LOSS.equals(methodName)) &&
isMethodOnFragmentClass(context, call,
FRAGMENT_TRANSACTION_CLS,
FRAGMENT_TRANSACTION_V4_CLS);
}
private static boolean isShowFragmentMethodCall(@NonNull JavaContext context,
@NonNull MethodInvocation call) {
String methodName = call.astName().astValue();
return SHOW.equals(methodName)
&& isMethodOnFragmentClass(context, call,
DIALOG_FRAGMENT, DIALOG_V4_FRAGMENT);
}
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;
}
@Nullable
public static ResolvedVariable getVariable(@NonNull JavaContext context,
@NonNull Node expression) {
Node parent = expression.getParent();
if (parent instanceof BinaryExpression) {
BinaryExpression binaryExpression = (BinaryExpression) parent;
if (binaryExpression.astOperator() == BinaryOperator.ASSIGN) {
Expression lhs = binaryExpression.astLeft();
ResolvedNode resolved = context.resolve(lhs);
if (resolved instanceof ResolvedVariable) {
return (ResolvedVariable) resolved;
}
}
} else if (parent instanceof VariableDefinitionEntry) {
ResolvedNode resolved = context.resolve(parent);
if (resolved instanceof ResolvedVariable) {
return (ResolvedVariable) resolved;
}
}
return null;
}
private static boolean isBeginTransaction(@NonNull JavaContext context,
@NonNull MethodInvocation node) {
String methodName = node.astName().astValue();
assert methodName.equals(BEGIN_TRANSACTION) : methodName;
if (BEGIN_TRANSACTION.equals(methodName)) {
ResolvedNode resolved = context.resolve(node);
if (resolved instanceof ResolvedMethod) {
ResolvedMethod method = (ResolvedMethod) resolved;
ResolvedClass containingClass = method.getContainingClass();
if (containingClass.isSubclassOf(FRAGMENT_MANAGER_CLS, false)
|| containingClass.isSubclassOf(FRAGMENT_MANAGER_V4_CLS,
false)) {
return true;
}
}
}
return false;
}
/**
* Visitor which checks whether an operation is "finished"; in the case
* of a FragmentTransaction we're looking for a "commit" call; in the
* case of a TypedArray we're looking for a "recycle", call, in the
* case of a database cursor we're looking for a "close" call, etc.
*/
private abstract static class FinishVisitor extends ForwardingAstVisitor {
protected final JavaContext mContext;
protected final List mVariables;
private boolean mContainsCleanup;
private boolean mEscapes;
public FinishVisitor(JavaContext context, @NonNull ResolvedVariable variable) {
mContext = context;
mVariables = Lists.newArrayList(variable);
}
public boolean isCleanedUp() {
return mContainsCleanup;
}
public boolean variableEscapes() {
return mEscapes;
}
@Override
public boolean visitNode(Node node) {
return mContainsCleanup || super.visitNode(node);
}
protected abstract boolean isCleanupCall(@NonNull MethodInvocation call);
@Override
public boolean visitMethodInvocation(MethodInvocation call) {
if (mContainsCleanup) {
return true;
}
super.visitMethodInvocation(call);
// Look for escapes
if (!mEscapes) {
for (Expression expression : call.astArguments()) {
if (expression instanceof VariableReference) {
ResolvedNode resolved = mContext.resolve(expression);
//noinspection SuspiciousMethodCalls
if (resolved != null && mVariables.contains(resolved)) {
mEscapes = true;
// Special case: MotionEvent.obtain(MotionEvent): passing in an
// event here does not recycle the event, and we also know it
// doesn't escape
if (OBTAIN.equals(call.astName().astValue())) {
ResolvedNode r = mContext.resolve(call);
if (r instanceof ResolvedMethod) {
ResolvedMethod method = (ResolvedMethod) r;
ResolvedClass cls = method.getContainingClass();
if (cls.matches(MOTION_EVENT_CLS)) {
mEscapes = false;
}
}
}
}
}
}
}
if (isCleanupCall(call)) {
mContainsCleanup = true;
return true;
} else {
return false;
}
}
@Override
public boolean visitVariableDefinitionEntry(VariableDefinitionEntry node) {
Expression initializer = node.astInitializer();
if (initializer instanceof VariableReference) {
ResolvedNode resolved = mContext.resolve(initializer);
//noinspection SuspiciousMethodCalls
if (resolved != null && mVariables.contains(resolved)) {
ResolvedNode resolvedVariable = mContext.resolve(node);
if (resolvedVariable instanceof ResolvedVariable) {
ResolvedVariable variable = (ResolvedVariable) resolvedVariable;
mVariables.add(variable);
} else if (resolvedVariable instanceof ResolvedField) {
mEscapes = true;
}
}
}
return super.visitVariableDefinitionEntry(node);
}
@Override
public boolean visitBinaryExpression(BinaryExpression node) {
if (node.astOperator() == BinaryOperator.ASSIGN) {
Expression rhs = node.astRight();
if (rhs instanceof VariableReference) {
ResolvedNode resolved = mContext.resolve(rhs);
//noinspection SuspiciousMethodCalls
if (resolved != null && mVariables.contains(resolved)) {
ResolvedNode resolvedLhs = mContext.resolve(node.astLeft());
if (resolvedLhs instanceof ResolvedVariable) {
ResolvedVariable variable = (ResolvedVariable) resolvedLhs;
mVariables.add(variable);
} else if (resolvedLhs instanceof ResolvedField) {
mEscapes = true;
}
}
}
}
return super.visitBinaryExpression(node);
}
@Override
public boolean visitReturn(Return node) {
Expression value = node.astValue();
if (value instanceof VariableReference) {
ResolvedNode resolved = mContext.resolve(value);
//noinspection SuspiciousMethodCalls
if (resolved != null && mVariables.contains(resolved)) {
mEscapes = true;
}
}
return super.visitReturn(node);
}
}
}
