Java tutorial
/* * 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; } }