/*
* Copyright (C) 2014 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.ANDROID_PREFIX;
import static com.android.SdkConstants.ANDROID_URI;
import static com.android.SdkConstants.ATTR_COLOR;
import static com.android.SdkConstants.ATTR_DRAWABLE;
import static com.android.SdkConstants.ATTR_LAYOUT;
import static com.android.SdkConstants.ATTR_NAME;
import static com.android.SdkConstants.ATTR_PARENT;
import static com.android.SdkConstants.ATTR_TYPE;
import static com.android.SdkConstants.COLOR_RESOURCE_PREFIX;
import static com.android.SdkConstants.DRAWABLE_PREFIX;
import static com.android.SdkConstants.LAYOUT_RESOURCE_PREFIX;
import static com.android.SdkConstants.NEW_ID_PREFIX;
import static com.android.SdkConstants.STYLE_RESOURCE_PREFIX;
import static com.android.SdkConstants.TAG_COLOR;
import static com.android.SdkConstants.TAG_ITEM;
import static com.android.SdkConstants.TAG_STYLE;
import static com.android.SdkConstants.VIEW_INCLUDE;
import com.android.annotations.NonNull;
import com.android.annotations.Nullable;
import com.android.resources.ResourceFolderType;
import com.android.resources.ResourceType;
import com.android.tools.lint.detector.api.Category;
import com.android.tools.lint.detector.api.Context;
import com.android.tools.lint.detector.api.Implementation;
import com.android.tools.lint.detector.api.Issue;
import com.android.tools.lint.detector.api.LintUtils;
import com.android.tools.lint.detector.api.Location;
import com.android.tools.lint.detector.api.ResourceXmlDetector;
import com.android.tools.lint.detector.api.Scope;
import com.android.tools.lint.detector.api.Severity;
import com.android.tools.lint.detector.api.Speed;
import com.android.tools.lint.detector.api.XmlContext;
import com.google.common.base.Joiner;
import com.google.common.base.Supplier;
import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Multimap;
import com.google.common.collect.Multimaps;
import com.google.common.collect.Sets;
import org.w3c.dom.Attr;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
/**
* Checks for cycles in resource definitions
*/
public class ResourceCycleDetector extends ResourceXmlDetector {
private static final Implementation IMPLEMENTATION = new Implementation(
ResourceCycleDetector.class,
Scope.RESOURCE_FILE_SCOPE);
/** Style parent cycles, resource alias cycles, layout include cycles, etc */
public static final Issue CYCLE = Issue.create(
"ResourceCycle", //$NON-NLS-1$
"Cycle in resource definitions",
"There should be no cycles in resource definitions as this can lead to runtime " +
"exceptions.",
Category.CORRECTNESS,
8,
Severity.FATAL,
IMPLEMENTATION
);
/** Parent cycles */
public static final Issue CRASH = Issue.create(
"AaptCrash", //$NON-NLS-1$
"Potential AAPT crash",
"Defining a style which sets `android:id` to a dynamically generated id can cause " +
"many versions of `aapt`, the resource packaging tool, to crash. To work around " +
"this, declare the id explicitly with `<item type=\"id\" name=\"...\" />` instead.",
Category.CORRECTNESS,
8,
Severity.FATAL,
IMPLEMENTATION)
.addMoreInfo("https://code.google.com/p/android/issues/detail?id=20479"); //$NON-NLS-1$
/**
* For each resource type, a map from a key (style name, layout name, color name, etc) to
* a value (parent style, included layout, referenced color, etc). Note that we only initialize
* this if we are in "batch mode" (not editor incremental mode) since we allow this detector
* to also run incrementally to look for trivial chains (e.g. of length 1).
*/
private Map<ResourceType, Multimap<String, String>> mReferences;
/**
* If in batch analysis and cycles were found, in phase 2 this map should be initialized
* with locations for declaration definitions of the keys and values in {@link #mReferences}
*/
private Map<ResourceType, Multimap<String, Location>> mLocations;
/**
* If in batch analysis and cycles were found, for each resource type this is a list
* of chains (where each chain is a list of keys as described in {@link #mReferences})
*/
private Map<ResourceType, List<List<String>>> mChains;
/** Constructs a new {@link ResourceCycleDetector} */
public ResourceCycleDetector() {
}
@Override
public void beforeCheckProject(@NonNull Context context) {
// In incremental mode, or checking all files (full lint analysis) ? If the latter,
// we should store state and look for deeper cycles
if (context.getScope().contains(Scope.ALL_RESOURCE_FILES)) {
mReferences = Maps.newEnumMap(ResourceType.class);
}
}
@Override
public boolean appliesTo(@NonNull ResourceFolderType folderType) {
return folderType == ResourceFolderType.VALUES
|| folderType == ResourceFolderType.COLOR
|| folderType == ResourceFolderType.DRAWABLE
|| folderType == ResourceFolderType.LAYOUT;
}
@NonNull
@Override
public Speed getSpeed() {
return Speed.FAST;
}
@Override
public Collection<String> getApplicableElements() {
return Arrays.asList(
VIEW_INCLUDE,
TAG_STYLE,
TAG_COLOR,
TAG_ITEM
);
}
private void recordReference(@NonNull ResourceType type, @NonNull String from,
@NonNull String to) {
if (to.isEmpty() || to.startsWith(ANDROID_PREFIX)) {
return;
}
assert mReferences != null;
Multimap<String, String> map = mReferences.get(type);
if (map == null) {
// Multimap which preserves insert order (for predictable output order)
map = Multimaps.newListMultimap(
new TreeMap<String, Collection<String>>(),
new Supplier<List<String>>() {
@Override
public List<String> get() {
return Lists.newArrayListWithExpectedSize(6);
}
});
mReferences.put(type, map);
}
if (to.charAt(0) == '@') {
int index = to.indexOf('/');
if (index != -1) {
to = to.substring(index + 1);
}
}
map.put(from, to);
}
private void recordLocation(@NonNull XmlContext context, @NonNull Node node,
@NonNull ResourceType type, @NonNull String from) {
assert mLocations != null;
// Cycles were already found; we're now in phase 2 looking up specific
// locations
Multimap<String, Location> map = mLocations.get(type);
if (map == null) {
map = ArrayListMultimap.create(30, 4);
mLocations.put(type, map);
}
Location location = context.getLocation(node);
map.put(from, location);
}
@SuppressWarnings("VariableNotUsedInsideIf")
@Override
public void visitElement(@NonNull XmlContext context, @NonNull Element element) {
String tagName = element.getTagName();
if (tagName.equals(TAG_ITEM)) {
if (mReferences == null) {
// Nothing to do in incremental mode
return;
}
ResourceFolderType folderType = context.getResourceFolderType();
if (folderType == ResourceFolderType.VALUES) {
// Aliases
Attr typeNode = element.getAttributeNode(ATTR_TYPE);
if (typeNode != null) {
String typeName = typeNode.getValue();
ResourceType type = ResourceType.getEnum(typeName);
Attr nameNode = element.getAttributeNode(ATTR_NAME);
if (type != null && nameNode != null) {
NodeList childNodes = element.getChildNodes();
for (int i = 0, n = childNodes.getLength(); i < n; i++) {
Node child = childNodes.item(i);
if (child.getNodeType() == Node.TEXT_NODE) {
String text = child.getNodeValue();
for (int k = 0, max = text.length(); k < max; k++) {
char c = text.charAt(k);
if (Character.isWhitespace(c)) {
break;
} else if (c == '@' &&
text.startsWith(type.getName(), k + 1)) {
String to = text.trim();
if (mReferences != null) {
String name = nameNode.getValue();
if (mLocations != null) {
recordLocation(context, child, type,
name);
} else {
recordReference(type, name, to);
}
}
} else {
break;
}
}
}
}
}
}
} else if (folderType == ResourceFolderType.COLOR ) {
String color = element.getAttributeNS(ANDROID_URI, ATTR_COLOR);
if (color != null && color.startsWith(COLOR_RESOURCE_PREFIX)) {
String currentColor = LintUtils.getBaseName(context.file.getName());
if (mLocations != null) {
recordLocation(context, element, ResourceType.COLOR,
currentColor);
} else {
recordReference(ResourceType.COLOR, currentColor,
color.substring(COLOR_RESOURCE_PREFIX.length()));
}
}
} else if (folderType == ResourceFolderType.DRAWABLE) {
String drawable = element.getAttributeNS(ANDROID_URI, ATTR_DRAWABLE);
if (drawable != null && drawable.startsWith(DRAWABLE_PREFIX)) {
String currentColor = LintUtils.getBaseName(context.file.getName());
if (mLocations != null) {
recordLocation(context, element, ResourceType.DRAWABLE,
currentColor);
} else {
recordReference(ResourceType.DRAWABLE, currentColor,
drawable.substring(DRAWABLE_PREFIX.length()));
}
}
}
} else if (tagName.equals(TAG_STYLE)) {
Attr nameNode = element.getAttributeNode(ATTR_NAME);
// Look for recursive style parent declarations
Attr parentNode = element.getAttributeNode(ATTR_PARENT);
if (parentNode != null && nameNode != null) {
String name = nameNode.getValue();
String parent = parentNode.getValue();
if (parent.endsWith(name) &&
parent.equals(STYLE_RESOURCE_PREFIX + name) && context.isEnabled(CYCLE)
&& context.getDriver().getPhase() == 1) {
context.report(CYCLE, parentNode, context.getLocation(parentNode),
String.format("Style `%1$s` should not extend itself", name));
} else if (parent.startsWith(STYLE_RESOURCE_PREFIX)
&& parent.startsWith(name, STYLE_RESOURCE_PREFIX.length())
&& parent.startsWith(".", STYLE_RESOURCE_PREFIX.length() + name.length())
&& context.isEnabled(CYCLE) && context.getDriver().getPhase() == 1) {
context.report(CYCLE, parentNode, context.getLocation(parentNode),
String.format("Potential cycle: `%1$s` is the implied parent of `%2$s` and " +
"this defines the opposite", name,
parent.substring(STYLE_RESOURCE_PREFIX.length())));
// Don't record this reference; we don't want to double report this
// as a chain, since this error is more helpful
return;
}
if (mReferences != null && !parent.isEmpty()) {
if (mLocations != null) {
recordLocation(context, parentNode, ResourceType.STYLE, name);
} else {
recordReference(ResourceType.STYLE, name, parent);
}
}
} else if (mReferences != null && nameNode != null) {
String name = nameNode.getValue();
int index = name.lastIndexOf('.');
if (index > 0) {
String parent = name.substring(0, index);
if (mReferences != null) {
if (mLocations != null) {
Attr node = element.getAttributeNode(ATTR_NAME);
recordLocation(context, node, ResourceType.STYLE, name);
} else {
recordReference(ResourceType.STYLE, name, parent);
}
}
}
}
if (context.isEnabled(CRASH) && context.getDriver().getPhase() == 1) {
for (Element item : LintUtils.getChildren(element)) {
if ("android:id".equals(item.getAttribute(ATTR_NAME))) {
checkCrashItem(context, item);
}
}
}
} else if (tagName.equals(VIEW_INCLUDE)) {
Attr layoutNode = element.getAttributeNode(ATTR_LAYOUT);
if (layoutNode != null) {
String layout = layoutNode.getValue();
if (layout.startsWith(LAYOUT_RESOURCE_PREFIX)) {
String currentLayout = LintUtils.getBaseName(context.file.getName());
if (mReferences != null) {
if (mLocations != null) {
recordLocation(context, layoutNode, ResourceType.LAYOUT,
currentLayout);
} else {
recordReference(ResourceType.LAYOUT, currentLayout, layout);
}
}
if (layout.startsWith(currentLayout, LAYOUT_RESOURCE_PREFIX.length()) &&
layout.length() == currentLayout.length()
+ LAYOUT_RESOURCE_PREFIX.length()
&& context.isEnabled(CYCLE)
&& context.getDriver().getPhase() == 1) {
String message = String.format("Layout `%1$s` should not include itself",
currentLayout);
context.report(CYCLE, layoutNode, context.getLocation(layoutNode),
message);
}
}
}
} else if (tagName.equals(TAG_COLOR)) {
NodeList childNodes = element.getChildNodes();
for (int i = 0, n = childNodes.getLength(); i < n; i++) {
Node child = childNodes.item(i);
if (child.getNodeType() == Node.TEXT_NODE) {
String text = child.getNodeValue();
for (int k = 0, max = text.length(); k < max; k++) {
char c = text.charAt(k);
if (Character.isWhitespace(c)) {
break;
} else if (text.startsWith(COLOR_RESOURCE_PREFIX, k)) {
String color = text.trim().substring(COLOR_RESOURCE_PREFIX.length());
String name = element.getAttribute(ATTR_NAME);
if (mReferences != null) {
if (mLocations != null) {
recordLocation(context, child, ResourceType.COLOR, name);
} else {
recordReference(ResourceType.COLOR, name, color);
}
}
if (color.equals(name)
&& context.isEnabled(CYCLE)
&& context.getDriver().getPhase() == 1) {
context.report(CYCLE, child, context.getLocation(child),
String.format("Color `%1$s` should not reference itself",
color));
}
} else {
break;
}
}
}
}
}
}
private static void checkCrashItem(@NonNull XmlContext context, @NonNull Element item) {
NodeList childNodes = item.getChildNodes();
for (int i = 0, n = childNodes.getLength(); i < n; i++) {
Node child = childNodes.item(i);
if (child.getNodeType() == Node.TEXT_NODE) {
String text = child.getNodeValue();
for (int k = 0, max = text.length(); k < max; k++) {
char c = text.charAt(k);
if (Character.isWhitespace(c)) {
return;
} else if (text.startsWith(NEW_ID_PREFIX, k)) {
String name = text.trim().substring(NEW_ID_PREFIX.length());
String message = "This construct can potentially crash `aapt` during a "
+ "build. Change `@+id/" + name + "` to `@id/" + name + "` and define "
+ "the id explicitly using "
+ "`<item type=\"id\" name=\"" + name + "\"/>` instead.";
context.report(CRASH, item, context.getLocation(item),
message);
} else {
return;
}
}
}
}
}
@Override
public void afterCheckProject(@NonNull Context context) {
if (mReferences == null) {
// Incremental analysis in a single file only; nothing to do
return;
}
int phase = context.getDriver().getPhase();
if (phase == 1) {
// Perform DFS of each resource type and look for cycles
for (Map.Entry<ResourceType, Multimap<String, String>> entry
: mReferences.entrySet()) {
ResourceType type = entry.getKey();
Multimap<String, String> map = entry.getValue();
findCycles(context, type, map);
}
} else {
assert phase == 2;
// Emit cycle report
for (Map.Entry<ResourceType, List<List<String>>> entry : mChains.entrySet()) {
ResourceType type = entry.getKey();
Multimap<String, Location> locations = mLocations.get(type);
if (locations == null) {
// No locations found. Unlikely.
locations = ArrayListMultimap.create();
}
List<List<String>> chains = entry.getValue();
for (List<String> chain : chains) {
Location location = null;
assert !chain.isEmpty();
for (int i = 0, n = chain.size(); i < n; i++) {
String item = chain.get(i);
Collection<Location> itemLocations = locations.get(item);
if (!itemLocations.isEmpty()) {
Location itemLocation = itemLocations.iterator().next();
String next = chain.get((i + 1) % chain.size());
String label = "Reference from @" + type.getName() + "/" + item
+ " to " + type.getName() + "/" + next + " here";
itemLocation.setMessage(label);
itemLocation.setSecondary(location);
location = itemLocation;
}
}
if (location == null) {
location = Location.create(context.getProject().getDir());
} else {
// Break off chain
Location curr = location.getSecondary();
while (curr != null) {
Location next = curr.getSecondary();
if (next == location) {
curr.setSecondary(null);
break;
}
curr = next;
}
}
String message = String.format("%1$s Resource definition cycle: %2$s",
type.getDisplayName(), Joiner.on(" => ").join(chain));
context.report(CYCLE, location, message);
}
}
}
}
private void findCycles(
@NonNull Context context,
@NonNull ResourceType type,
@NonNull Multimap<String, String> map) {
Set<String> visiting = Sets.newHashSetWithExpectedSize(map.size());
Set<String> seen = Sets.newHashSetWithExpectedSize(map.size());
for (String from : map.keySet()) {
if (seen.contains(from)) {
continue;
}
List<String> chain = dfs(map, from, visiting);
if (chain != null && chain.size() > 2) { // size 1 chains are handled directly
seen.addAll(chain);
Collections.reverse(chain);
if (mChains == null) {
mChains = Maps.newEnumMap(ResourceType.class);
mLocations = Maps.newEnumMap(ResourceType.class);
context.getDriver().requestRepeat(this, Scope.RESOURCE_FILE_SCOPE);
}
List<List<String>> list = mChains.get(type);
if (list == null) {
list = Lists.newArrayList();
mChains.put(type, list);
}
list.add(chain);
}
}
}
// ----- Cycle detection -----
@Nullable
private static List<String> dfs(
@NonNull Multimap<String, String> map,
@NonNull String from,
@NonNull Set<String> visiting) {
visiting.add(from);
Collection<String> targets = map.get(from);
if (targets != null && !targets.isEmpty()) {
for (String target : targets) {
if (visiting.contains(target)) {
List<String> chain = Lists.newArrayList();
chain.add(target);
chain.add(from);
return chain;
}
List<String> chain = dfs(map, target, visiting);
if (chain != null) {
chain.add(from);
return chain;
}
}
}
visiting.remove(from);
return null;
}
}