| /* |
| * Copyright (C) 2011 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_URI; |
| import static com.android.SdkConstants.ATTR_ID; |
| import static com.android.SdkConstants.ATTR_LAYOUT_RESOURCE_PREFIX; |
| import static com.android.SdkConstants.ATTR_NAME; |
| import static com.android.SdkConstants.ATTR_TYPE; |
| import static com.android.SdkConstants.FD_RES_VALUES; |
| import static com.android.SdkConstants.ID_PREFIX; |
| import static com.android.SdkConstants.NEW_ID_PREFIX; |
| import static com.android.SdkConstants.RELATIVE_LAYOUT; |
| import static com.android.SdkConstants.TAG_ITEM; |
| import static com.android.SdkConstants.VALUE_ID; |
| import static com.android.tools.lint.detector.api.LintUtils.editDistance; |
| import static com.android.tools.lint.detector.api.LintUtils.getChildren; |
| import static com.android.tools.lint.detector.api.LintUtils.isSameResourceFile; |
| import static com.android.tools.lint.detector.api.LintUtils.stripIdPrefix; |
| |
| import com.android.annotations.NonNull; |
| import com.android.annotations.Nullable; |
| import com.android.ide.common.res2.AbstractResourceRepository; |
| import com.android.ide.common.res2.ResourceFile; |
| import com.android.ide.common.res2.ResourceItem; |
| import com.android.resources.ResourceFolderType; |
| import com.android.resources.ResourceType; |
| import com.android.tools.lint.client.api.LintClient; |
| 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.LayoutDetector; |
| import com.android.tools.lint.detector.api.Location; |
| import com.android.tools.lint.detector.api.Location.Handle; |
| 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.android.utils.Pair; |
| import com.google.common.base.Joiner; |
| import com.google.common.collect.ArrayListMultimap; |
| import com.google.common.collect.Multimap; |
| import com.google.common.collect.Sets; |
| |
| import org.w3c.dom.Attr; |
| import org.w3c.dom.Element; |
| import org.w3c.dom.NamedNodeMap; |
| import org.w3c.dom.Node; |
| |
| import java.io.File; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Set; |
| |
| /** |
| * Checks for duplicate ids within a layout and within an included layout |
| */ |
| public class WrongIdDetector extends LayoutDetector { |
| private static final Implementation IMPLEMENTATION = new Implementation( |
| WrongIdDetector.class, |
| Scope.RESOURCE_FILE_SCOPE); |
| |
| /** Ids bound to widgets in any of the layout files */ |
| private final Set<String> mGlobalIds = new HashSet<String>(100); |
| |
| /** Ids bound to widgets in the current layout file */ |
| private Set<String> mFileIds; |
| |
| /** Ids declared in a value's file, e.g. {@code <item type="id" name="foo"/>} */ |
| private Set<String> mDeclaredIds; |
| |
| /** |
| * Location handles for the various id references that were not found as |
| * defined in the same layout, to be checked after the whole project has |
| * been scanned |
| */ |
| private List<Pair<String, Location.Handle>> mHandles; |
| |
| /** List of RelativeLayout elements in the current layout */ |
| private List<Element> mRelativeLayouts; |
| |
| /** Reference to an unknown id */ |
| @SuppressWarnings("unchecked") |
| public static final Issue UNKNOWN_ID = Issue.create( |
| "UnknownId", //$NON-NLS-1$ |
| "Reference to an unknown id", |
| "The `@+id/` syntax refers to an existing id, or creates a new one if it has " + |
| "not already been defined elsewhere. However, this means that if you have a " + |
| "typo in your reference, or if the referred view no longer exists, you do not " + |
| "get a warning since the id will be created on demand. This check catches " + |
| "errors where you have renamed an id without updating all of the references to " + |
| "it.", |
| Category.CORRECTNESS, |
| 8, |
| Severity.FATAL, |
| new Implementation( |
| WrongIdDetector.class, |
| Scope.ALL_RESOURCES_SCOPE, |
| Scope.RESOURCE_FILE_SCOPE)); |
| |
| /** Reference to an id that is not a sibling */ |
| public static final Issue NOT_SIBLING = Issue.create( |
| "NotSibling", //$NON-NLS-1$ |
| "RelativeLayout Invalid Constraints", |
| "Layout constraints in a given `RelativeLayout` should reference other views " + |
| "within the same relative layout (but not itself!)", |
| Category.CORRECTNESS, |
| 6, |
| Severity.FATAL, |
| IMPLEMENTATION); |
| |
| /** An ID declaration which is not valid */ |
| public static final Issue INVALID = Issue.create( |
| "InvalidId", //$NON-NLS-1$ |
| "Invalid ID declaration", |
| "An id definition *must* be of the form `@+id/yourname`. The tools have not " + |
| "rejected strings of the form `@+foo/bar` in the past, but that was an error, " + |
| "and could lead to tricky errors because of the way the id integers are assigned.\n" + |
| "\n" + |
| "If you really want to have different \"scopes\" for your id's, use prefixes " + |
| "instead, such as `login_button1` and `login_button2`.", |
| Category.CORRECTNESS, |
| 6, |
| Severity.FATAL, |
| IMPLEMENTATION); |
| |
| /** Reference to an id that is not in the current layout */ |
| public static final Issue UNKNOWN_ID_LAYOUT = Issue.create( |
| "UnknownIdInLayout", //$NON-NLS-1$ |
| "Reference to an id that is not in the current layout", |
| |
| "The `@+id/` syntax refers to an existing id, or creates a new one if it has " + |
| "not already been defined elsewhere. However, this means that if you have a " + |
| "typo in your reference, or if the referred view no longer exists, you do not " + |
| "get a warning since the id will be created on demand.\n" + |
| "\n" + |
| "This is sometimes intentional, for example where you are referring to a view " + |
| "which is provided in a different layout via an include. However, it is usually " + |
| "an accident where you have a typo or you have renamed a view without updating " + |
| "all the references to it.", |
| |
| Category.CORRECTNESS, |
| 5, |
| Severity.WARNING, |
| new Implementation( |
| WrongIdDetector.class, |
| Scope.RESOURCE_FILE_SCOPE)); |
| |
| /** Constructs a duplicate id check */ |
| public WrongIdDetector() { |
| } |
| |
| @Override |
| public boolean appliesTo(@NonNull ResourceFolderType folderType) { |
| return folderType == ResourceFolderType.LAYOUT || folderType == ResourceFolderType.VALUES; |
| } |
| |
| @NonNull |
| @Override |
| public Speed getSpeed() { |
| return Speed.FAST; |
| } |
| |
| @Override |
| public Collection<String> getApplicableAttributes() { |
| return Collections.singletonList(ATTR_ID); |
| } |
| |
| @Override |
| public Collection<String> getApplicableElements() { |
| return Arrays.asList(RELATIVE_LAYOUT, TAG_ITEM); |
| } |
| |
| @Override |
| public void beforeCheckFile(@NonNull Context context) { |
| mFileIds = new HashSet<String>(); |
| mRelativeLayouts = null; |
| } |
| |
| @Override |
| public void afterCheckFile(@NonNull Context context) { |
| if (mRelativeLayouts != null) { |
| if (!context.getProject().getReportIssues()) { |
| // If this is a library project not being analyzed, ignore it |
| return; |
| } |
| |
| for (Element layout : mRelativeLayouts) { |
| List<Element> children = getChildren(layout); |
| Set<String> ids = Sets.newHashSetWithExpectedSize(children.size()); |
| for (Element child : children) { |
| String id = child.getAttributeNS(ANDROID_URI, ATTR_ID); |
| if (id != null && !id.isEmpty()) { |
| ids.add(id); |
| } |
| } |
| |
| for (Element element : children) { |
| String selfId = stripIdPrefix(element.getAttributeNS(ANDROID_URI, ATTR_ID)); |
| |
| NamedNodeMap attributes = element.getAttributes(); |
| for (int i = 0, n = attributes.getLength(); i < n; i++) { |
| Attr attr = (Attr) attributes.item(i); |
| String value = attr.getValue(); |
| if ((value.startsWith(NEW_ID_PREFIX) || |
| value.startsWith(ID_PREFIX)) |
| && ANDROID_URI.equals(attr.getNamespaceURI()) |
| && attr.getLocalName().startsWith(ATTR_LAYOUT_RESOURCE_PREFIX)) { |
| if (!idDefined(mFileIds, value)) { |
| // Stash a reference to this id and location such that |
| // we can check after the *whole* layout has been processed, |
| // since it's too early to conclude here that the id does |
| // not exist (you are allowed to have forward references) |
| XmlContext xmlContext = (XmlContext) context; |
| Handle handle = xmlContext.createLocationHandle(attr); |
| handle.setClientData(attr); |
| |
| if (mHandles == null) { |
| mHandles = new ArrayList<Pair<String,Handle>>(); |
| } |
| mHandles.add(Pair.of(value, handle)); |
| } else { |
| // Check siblings. TODO: Look for cycles! |
| if (ids.contains(value)) { |
| // Make sure it's not pointing to self |
| if (!ATTR_ID.equals(attr.getLocalName()) |
| && !selfId.isEmpty() |
| && value.endsWith(selfId) |
| && stripIdPrefix(value).equals(selfId)) { |
| XmlContext xmlContext = (XmlContext) context; |
| String message = String.format( |
| "Cannot be relative to self: id=%1$s, %2$s=%3$s", |
| selfId, attr.getLocalName(), selfId); |
| Location location = xmlContext.getLocation(attr); |
| xmlContext.report(NOT_SIBLING, attr, location, message); |
| } |
| |
| continue; |
| } |
| if (value.startsWith(NEW_ID_PREFIX)) { |
| if (ids.contains(ID_PREFIX + stripIdPrefix(value))) { |
| continue; |
| } |
| } else { |
| assert value.startsWith(ID_PREFIX) : value; |
| if (ids.contains(NEW_ID_PREFIX + stripIdPrefix(value))) { |
| continue; |
| } |
| } |
| if (context.isEnabled(NOT_SIBLING)) { |
| XmlContext xmlContext = (XmlContext) context; |
| String message = String.format( |
| "`%1$s` is not a sibling in the same `RelativeLayout`", |
| value); |
| Location location = xmlContext.getLocation(attr); |
| xmlContext.report(NOT_SIBLING, attr, location, message); |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| mFileIds = null; |
| |
| if (!context.getScope().contains(Scope.ALL_RESOURCE_FILES)) { |
| checkHandles(context); |
| } |
| } |
| |
| @Override |
| public void afterCheckProject(@NonNull Context context) { |
| if (context.getScope().contains(Scope.ALL_RESOURCE_FILES)) { |
| checkHandles(context); |
| } |
| } |
| |
| private void checkHandles(@NonNull Context context) { |
| if (mHandles != null) { |
| boolean checkSameLayout = context.isEnabled(UNKNOWN_ID_LAYOUT); |
| boolean checkExists = context.isEnabled(UNKNOWN_ID); |
| boolean projectScope = context.getScope().contains(Scope.ALL_RESOURCE_FILES); |
| for (Pair<String, Handle> pair : mHandles) { |
| String id = pair.getFirst(); |
| boolean isBound = projectScope ? idDefined(mGlobalIds, id) : |
| idDefined(context, id, context.file); |
| LintClient client = context.getClient(); |
| if (!isBound && checkExists |
| && (projectScope || client.supportsProjectResources())) { |
| Handle handle = pair.getSecond(); |
| boolean isDeclared = idDefined(mDeclaredIds, id); |
| id = stripIdPrefix(id); |
| String suggestionMessage; |
| Set<String> spellingDictionary = mGlobalIds; |
| if (!projectScope && client.supportsProjectResources()) { |
| AbstractResourceRepository resources = |
| client.getProjectResources(context.getProject(), true); |
| if (resources != null) { |
| spellingDictionary = Sets.newHashSet( |
| resources.getItemsOfType(ResourceType.ID)); |
| spellingDictionary.remove(id); |
| } |
| } |
| List<String> suggestions = getSpellingSuggestions(id, spellingDictionary); |
| if (suggestions.size() > 1) { |
| suggestionMessage = String.format(" Did you mean one of {%2$s} ?", |
| id, Joiner.on(", ").join(suggestions)); |
| } else if (!suggestions.isEmpty()) { |
| suggestionMessage = String.format(" Did you mean %2$s ?", |
| id, suggestions.get(0)); |
| } else { |
| suggestionMessage = ""; |
| } |
| String message; |
| if (isDeclared) { |
| message = String.format( |
| "The id \"`%1$s`\" is defined but not assigned to any views.%2$s", |
| id, suggestionMessage); |
| } else { |
| message = String.format( |
| "The id \"`%1$s`\" is not defined anywhere.%2$s", |
| id, suggestionMessage); |
| } |
| report(context, UNKNOWN_ID, handle, message); |
| } else if (checkSameLayout && (!projectScope || isBound) |
| && id.startsWith(NEW_ID_PREFIX)) { |
| // The id was defined, but in a different layout. Usually not intentional |
| // (might be referring to a random other view that happens to have the same |
| // name.) |
| Handle handle = pair.getSecond(); |
| report(context, UNKNOWN_ID_LAYOUT, handle, |
| String.format( |
| "The id \"`%1$s`\" is not referring to any views in this layout", |
| stripIdPrefix(id))); |
| } |
| } |
| } |
| } |
| |
| private static void report(Context context, Issue issue, Handle handle, String message) { |
| Location location = handle.resolve(); |
| Object clientData = handle.getClientData(); |
| if (clientData instanceof Node) { |
| if (context.getDriver().isSuppressed(null, issue, (Node) clientData)) { |
| return; |
| } |
| } |
| |
| context.report(issue, location, message); |
| } |
| |
| @Override |
| public void visitElement(@NonNull XmlContext context, @NonNull Element element) { |
| if (element.getTagName().equals(RELATIVE_LAYOUT)) { |
| if (mRelativeLayouts == null) { |
| mRelativeLayouts = new ArrayList<Element>(); |
| } |
| mRelativeLayouts.add(element); |
| } else { |
| assert element.getTagName().equals(TAG_ITEM); |
| String type = element.getAttribute(ATTR_TYPE); |
| if (VALUE_ID.equals(type)) { |
| String name = element.getAttribute(ATTR_NAME); |
| if (!name.isEmpty()) { |
| if (mDeclaredIds == null) { |
| mDeclaredIds = Sets.newHashSet(); |
| } |
| mDeclaredIds.add(ID_PREFIX + name); |
| } |
| } |
| } |
| } |
| |
| @Override |
| public void visitAttribute(@NonNull XmlContext context, @NonNull Attr attribute) { |
| assert attribute.getName().equals(ATTR_ID) || attribute.getLocalName().equals(ATTR_ID); |
| String id = attribute.getValue(); |
| mFileIds.add(id); |
| mGlobalIds.add(id); |
| |
| if (id.equals(NEW_ID_PREFIX) || id.equals(ID_PREFIX) || "@+id".equals(ID_PREFIX)) { |
| String message = "Invalid id: missing value"; |
| context.report(INVALID, attribute, context.getLocation(attribute), message); |
| } else if (id.startsWith("@+") && !id.startsWith(NEW_ID_PREFIX) //$NON-NLS-1$ |
| && !id.startsWith("@+android:id/") //$NON-NLS-1$ |
| || id.startsWith(NEW_ID_PREFIX) |
| && id.indexOf('/', NEW_ID_PREFIX.length()) != -1) { |
| int nameStart = id.startsWith(NEW_ID_PREFIX) ? NEW_ID_PREFIX.length() : 2; |
| String suggested = NEW_ID_PREFIX + id.substring(nameStart).replace('/', '_'); |
| String message = String.format( |
| "ID definitions *must* be of the form `@+id/name`; try using `%1$s`", suggested); |
| context.report(INVALID, attribute, context.getLocation(attribute), message); |
| } |
| } |
| |
| private static boolean idDefined(Set<String> ids, String id) { |
| if (ids == null) { |
| return false; |
| } |
| boolean definedLocally = ids.contains(id); |
| if (!definedLocally) { |
| if (id.startsWith(NEW_ID_PREFIX)) { |
| definedLocally = ids.contains(ID_PREFIX + |
| id.substring(NEW_ID_PREFIX.length())); |
| } else if (id.startsWith(ID_PREFIX)) { |
| definedLocally = ids.contains(NEW_ID_PREFIX + |
| id.substring(ID_PREFIX.length())); |
| } |
| } |
| |
| return definedLocally; |
| } |
| |
| private boolean idDefined(@NonNull Context context, @NonNull String id, |
| @Nullable File notIn) { |
| AbstractResourceRepository resources = |
| context.getClient().getProjectResources(context.getProject(), true); |
| if (resources != null) { |
| List<ResourceItem> items = resources.getResourceItem(ResourceType.ID, |
| stripIdPrefix(id)); |
| if (items == null || items.isEmpty()) { |
| return false; |
| } |
| for (ResourceItem item : items) { |
| ResourceFile source = item.getSource(); |
| if (source != null) { |
| File file = source.getFile(); |
| if (file.getParentFile().getName().startsWith(FD_RES_VALUES)) { |
| if (mDeclaredIds == null) { |
| mDeclaredIds = Sets.newHashSet(); |
| } |
| mDeclaredIds.add(id); |
| continue; |
| } |
| |
| // Ignore definitions in the given file. This is used to ignore |
| // matches in the same file as the reference, since the reference |
| // is often expressed as a definition |
| if (!isSameResourceFile(file, notIn)) { |
| return true; |
| } |
| } |
| } |
| } |
| |
| return false; |
| } |
| |
| private static List<String> getSpellingSuggestions(String id, Collection<String> ids) { |
| int maxDistance = id.length() >= 4 ? 2 : 1; |
| |
| // Look for typos and try to match with custom views and android views |
| Multimap<Integer, String> matches = ArrayListMultimap.create(2, 10); |
| int count = 0; |
| if (!ids.isEmpty()) { |
| for (String matchWith : ids) { |
| matchWith = stripIdPrefix(matchWith); |
| if (Math.abs(id.length() - matchWith.length()) > maxDistance) { |
| // The string lengths differ more than the allowed edit distance; |
| // no point in even attempting to compute the edit distance (requires |
| // O(n*m) storage and O(n*m) speed, where n and m are the string lengths) |
| continue; |
| } |
| int distance = editDistance(id, matchWith); |
| if (distance <= maxDistance) { |
| matches.put(distance, matchWith); |
| } |
| |
| if (count++ > 100) { |
| // Make sure that for huge projects we don't completely grind to a halt |
| break; |
| } |
| } |
| } |
| |
| for (int i = 0; i < maxDistance; i++) { |
| Collection<String> strings = matches.get(i); |
| if (strings != null && !strings.isEmpty()) { |
| List<String> suggestions = new ArrayList<String>(strings); |
| Collections.sort(suggestions); |
| return suggestions; |
| } |
| } |
| |
| return Collections.emptyList(); |
| } |
| } |
