| /* |
| * 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_BASELINE_ALIGNED; |
| import static com.android.SdkConstants.ATTR_ID; |
| import static com.android.SdkConstants.ATTR_LAYOUT_HEIGHT; |
| import static com.android.SdkConstants.ATTR_LAYOUT_WEIGHT; |
| import static com.android.SdkConstants.ATTR_LAYOUT_WIDTH; |
| import static com.android.SdkConstants.ATTR_ORIENTATION; |
| import static com.android.SdkConstants.ATTR_STYLE; |
| import static com.android.SdkConstants.LINEAR_LAYOUT; |
| import static com.android.SdkConstants.RADIO_GROUP; |
| import static com.android.SdkConstants.SPACE; |
| import static com.android.SdkConstants.VALUE_FALSE; |
| import static com.android.SdkConstants.VALUE_FILL_PARENT; |
| import static com.android.SdkConstants.VALUE_HORIZONTAL; |
| import static com.android.SdkConstants.VALUE_MATCH_PARENT; |
| import static com.android.SdkConstants.VALUE_VERTICAL; |
| import static com.android.SdkConstants.VIEW; |
| import static com.android.SdkConstants.VIEW_FRAGMENT; |
| import static com.android.SdkConstants.VIEW_INCLUDE; |
| import static com.android.SdkConstants.VIEW_TAG; |
| |
| import com.android.annotations.NonNull; |
| import com.android.ide.common.rendering.api.ResourceValue; |
| import com.android.tools.lint.client.api.SdkInfo; |
| import com.android.tools.lint.detector.api.Category; |
| 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.Lint; |
| import com.android.tools.lint.detector.api.LintFix; |
| import com.android.tools.lint.detector.api.Scope; |
| import com.android.tools.lint.detector.api.Severity; |
| import com.android.tools.lint.detector.api.XmlContext; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.IdentityHashMap; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import org.w3c.dom.Attr; |
| import org.w3c.dom.Element; |
| import org.w3c.dom.Node; |
| |
| /** Checks whether a layout_weight is declared inefficiently. */ |
| public class InefficientWeightDetector extends LayoutDetector { |
| |
| private static final Implementation IMPLEMENTATION = |
| new Implementation(InefficientWeightDetector.class, Scope.RESOURCE_FILE_SCOPE); |
| |
| /** Can a weight be replaced with 0dp instead for better performance? */ |
| public static final Issue INEFFICIENT_WEIGHT = |
| Issue.create( |
| "InefficientWeight", |
| "Inefficient layout weight", |
| "When only a single widget in a `LinearLayout` defines a weight, it is more " |
| + "efficient to assign a width/height of `0dp` to it since it will absorb all " |
| + "the remaining space anyway. With a declared width/height of `0dp` it " |
| + "does not have to measure its own size first.", |
| Category.PERFORMANCE, |
| 3, |
| Severity.WARNING, |
| IMPLEMENTATION); |
| |
| /** Are weights nested? */ |
| public static final Issue NESTED_WEIGHTS = |
| Issue.create( |
| "NestedWeights", |
| "Nested layout weights", |
| "Layout weights require a widget to be measured twice. When a `LinearLayout` with " |
| + "non-zero weights is nested inside another `LinearLayout` with non-zero weights, " |
| + "then the number of measurements increase exponentially.", |
| Category.PERFORMANCE, |
| 3, |
| Severity.WARNING, |
| IMPLEMENTATION); |
| |
| /** Should a LinearLayout set android:baselineAligned? */ |
| public static final Issue BASELINE_WEIGHTS = |
| Issue.create( |
| "DisableBaselineAlignment", |
| "Missing `baselineAligned` attribute", |
| "When a `LinearLayout` is used to distribute the space proportionally between " |
| + "nested layouts, the baseline alignment property should be turned off to " |
| + "make the layout computation faster.", |
| Category.PERFORMANCE, |
| 3, |
| Severity.WARNING, |
| IMPLEMENTATION); |
| |
| /** Using 0dp on the wrong dimension */ |
| public static final Issue WRONG_0DP = |
| Issue.create( |
| "Suspicious0dp", |
| "Suspicious 0dp dimension", |
| "Using 0dp as the width in a horizontal `LinearLayout` with weights is a useful " |
| + "trick to ensure that only the weights (and not the intrinsic sizes) are used " |
| + "when sizing the children.\n" |
| + "\n" |
| + "However, if you use 0dp for the opposite dimension, the view will be invisible. " |
| + "This can happen if you change the orientation of a layout without also flipping " |
| + "the `0dp` dimension in all the children.", |
| Category.CORRECTNESS, |
| 6, |
| Severity.ERROR, |
| IMPLEMENTATION); |
| |
| /** Missing explicit orientation */ |
| public static final Issue ORIENTATION = |
| Issue.create( |
| "Orientation", |
| "Missing explicit orientation", |
| "The default orientation of a `LinearLayout` is horizontal. It's pretty easy to " |
| + "believe that the layout is vertical, add multiple children to it, and wonder " |
| + "why only the first child is visible (when the subsequent children are " |
| + "off screen to the right). This lint rule helps pinpoint this issue by " |
| + "warning whenever a `LinearLayout` is used with an implicit orientation " |
| + "and multiple children.\n" |
| + "\n" |
| + "It also checks for empty LinearLayouts without an `orientation` attribute " |
| + "that also defines an `id` attribute. This catches the scenarios where " |
| + "children will be added to the `LinearLayout` dynamically. ", |
| Category.CORRECTNESS, |
| 2, |
| Severity.ERROR, |
| IMPLEMENTATION); |
| |
| /** |
| * Map from element to whether that element has a non-zero linear layout weight or has an |
| * ancestor which does |
| */ |
| private final Map<Node, Boolean> mInsideWeight = new IdentityHashMap<>(); |
| |
| /** Constructs a new {@link InefficientWeightDetector} */ |
| public InefficientWeightDetector() {} |
| |
| @Override |
| public Collection<String> getApplicableElements() { |
| return Collections.singletonList(LINEAR_LAYOUT); |
| } |
| |
| @Override |
| public void visitElement(@NonNull XmlContext context, @NonNull Element element) { |
| List<Element> children = Lint.getChildren(element); |
| // See if there is exactly one child with a weight |
| boolean multipleWeights = false; |
| Element weightChild = null; |
| boolean checkNesting = context.isEnabled(NESTED_WEIGHTS); |
| for (Element child : children) { |
| if (child.hasAttributeNS(ANDROID_URI, ATTR_LAYOUT_WEIGHT)) { |
| if (weightChild != null) { |
| // More than one child defining a weight! |
| multipleWeights = true; |
| } else //noinspection ConstantConditions |
| if (!multipleWeights) { |
| weightChild = child; |
| } |
| |
| if (checkNesting) { |
| mInsideWeight.put(child, Boolean.TRUE); |
| |
| Boolean inside = mInsideWeight.get(element); |
| if (inside == null) { |
| mInsideWeight.put(element, Boolean.FALSE); |
| } else if (inside) { |
| Attr sizeNode = child.getAttributeNodeNS(ANDROID_URI, ATTR_LAYOUT_WEIGHT); |
| context.report( |
| NESTED_WEIGHTS, |
| sizeNode, |
| context.getLocation(sizeNode), |
| "Nested weights are bad for performance"); |
| // Don't warn again |
| checkNesting = false; |
| } |
| } |
| } |
| } |
| |
| String orientation = element.getAttributeNS(ANDROID_URI, ATTR_ORIENTATION); |
| if (children.size() >= 2 |
| && (orientation == null || orientation.isEmpty()) |
| && context.isEnabled(ORIENTATION)) { |
| // See if at least one of the children, except the last one, sets layout_width |
| // to match_parent (or fill_parent), in an implicitly horizontal layout, since |
| // that might mean the last child won't be visible. This is a source of confusion |
| // for new Android developers. |
| boolean maxWidthSet = false; |
| Iterator<Element> iterator = children.iterator(); |
| while (iterator.hasNext()) { |
| Element child = iterator.next(); |
| if (!iterator.hasNext()) { // Don't check the last one |
| break; |
| } |
| String width = child.getAttributeNS(ANDROID_URI, ATTR_LAYOUT_WIDTH); |
| if (VALUE_MATCH_PARENT.equals(width) || VALUE_FILL_PARENT.equals(width)) { |
| // Also check that weights are not set here; this affects the computation |
| // a bit and the child may not fill up the whole linear layout |
| if (!child.hasAttributeNS(ANDROID_URI, ATTR_LAYOUT_WEIGHT)) { |
| maxWidthSet = true; |
| break; |
| } |
| } |
| } |
| if (maxWidthSet && !element.hasAttribute(ATTR_STYLE)) { |
| String message = |
| "Wrong orientation? No orientation specified, and the default " |
| + "is horizontal, yet this layout has multiple children where at " |
| + "least one has `layout_width=\"match_parent\"`"; |
| context.report( |
| ORIENTATION, |
| element, |
| context.getNameLocation(element), |
| message, |
| createOrientationFixes()); |
| } |
| } else if (children.isEmpty() |
| && (orientation == null || orientation.isEmpty()) |
| && context.isEnabled(ORIENTATION) |
| && element.hasAttributeNS(ANDROID_URI, ATTR_ID)) { |
| boolean ignore; |
| if (element.hasAttribute(ATTR_STYLE)) { |
| if (context.getClient().supportsProjectResources()) { |
| List<ResourceValue> values = |
| Lint.getStyleAttributes( |
| context.getMainProject(), |
| context.getClient(), |
| element.getAttribute(ATTR_STYLE), |
| ANDROID_URI, |
| ATTR_ORIENTATION); |
| ignore = values != null && !values.isEmpty(); |
| } else { |
| ignore = true; |
| } |
| } else { |
| ignore = false; |
| } |
| if (!ignore) { |
| String message = |
| "No orientation specified, and the default is horizontal. " |
| + "This is a common source of bugs when children are added dynamically."; |
| context.report( |
| ORIENTATION, |
| element, |
| context.getNameLocation(element), |
| message, |
| createOrientationFixes()); |
| } |
| } |
| |
| if (context.isEnabled(BASELINE_WEIGHTS) |
| && weightChild != null |
| && !VALUE_VERTICAL.equals(orientation) |
| && !element.hasAttributeNS(ANDROID_URI, ATTR_BASELINE_ALIGNED)) { |
| // See if all the children are layouts |
| boolean allChildrenAreLayouts = !children.isEmpty(); |
| SdkInfo sdkInfo = context.getClient().getSdkInfo(context.getProject()); |
| for (Element child : children) { |
| String tagName = child.getTagName(); |
| if (!(sdkInfo.isLayout(tagName) |
| // RadioGroup is a layout, but one which possibly should be base aligned |
| && !tagName.equals(RADIO_GROUP) |
| // Consider <fragment> tags as layouts for the purposes of this check |
| || VIEW_FRAGMENT.equals(tagName) |
| // Ditto for <include> tags |
| || VIEW_INCLUDE.equals(tagName))) { |
| allChildrenAreLayouts = false; |
| } |
| } |
| if (allChildrenAreLayouts) { |
| LintFix fix = |
| fix().set(ANDROID_URI, ATTR_BASELINE_ALIGNED, VALUE_FALSE) |
| .autoFix() |
| .build(); |
| context.report( |
| BASELINE_WEIGHTS, |
| element, |
| context.getNameLocation(element), |
| "Set `android:baselineAligned=\"false\"` on this element for better performance", |
| fix); |
| } |
| } |
| |
| if (context.isEnabled(INEFFICIENT_WEIGHT) && weightChild != null && !multipleWeights) { |
| String dimension; |
| if (VALUE_VERTICAL.equals(orientation)) { |
| dimension = ATTR_LAYOUT_HEIGHT; |
| } else { |
| dimension = ATTR_LAYOUT_WIDTH; |
| } |
| Attr sizeNode = weightChild.getAttributeNodeNS(ANDROID_URI, dimension); |
| String size = sizeNode != null ? sizeNode.getValue() : "(undefined)"; |
| if (sizeNode == null && weightChild.hasAttribute(ATTR_STYLE)) { |
| String style = weightChild.getAttribute(ATTR_STYLE); |
| List<ResourceValue> sizes = |
| Lint.getStyleAttributes( |
| context.getMainProject(), |
| context.getClient(), |
| style, |
| ANDROID_URI, |
| dimension); |
| if (sizes != null) { |
| for (ResourceValue value : sizes) { |
| String v = value.getValue(); |
| if (v != null) { |
| size = v; |
| if (v.startsWith("0")) { |
| break; |
| } |
| } |
| } |
| } |
| } |
| if (!size.startsWith("0")) { |
| String msg = |
| String.format( |
| "Use a `%1$s` of `0dp` instead of `%2$s` for better performance", |
| dimension, size); |
| context.report( |
| INEFFICIENT_WEIGHT, |
| weightChild, |
| context.getElementLocation(weightChild, sizeNode, null, null), |
| msg); |
| } |
| } |
| |
| if (context.isEnabled(WRONG_0DP)) { |
| checkWrong0Dp(context, element, children); |
| } |
| } |
| |
| @NonNull |
| private LintFix createOrientationFixes() { |
| LintFix horizontal = |
| fix().name("Set orientation=\"horizontal\" (default)") |
| .set(ANDROID_URI, ATTR_ORIENTATION, VALUE_HORIZONTAL) |
| .build(); |
| LintFix vertical = |
| fix().name("Set orientation=\"vertical\" (changes layout)") |
| .set(ANDROID_URI, ATTR_ORIENTATION, VALUE_VERTICAL) |
| .build(); |
| return fix().alternatives(horizontal, vertical); |
| } |
| |
| private static void checkWrong0Dp(XmlContext context, Element element, List<Element> children) { |
| boolean isVertical = false; |
| String orientation = element.getAttributeNS(ANDROID_URI, ATTR_ORIENTATION); |
| if (VALUE_VERTICAL.equals(orientation)) { |
| isVertical = true; |
| } |
| |
| for (Element child : children) { |
| String tagName = child.getTagName(); |
| if (tagName.equals(VIEW)) { |
| // Might just used for spacing |
| return; |
| } |
| if (tagName.indexOf('.') != -1 || tagName.equals(VIEW_TAG)) { |
| // Custom views might perform their own dynamic sizing or ignore the layout |
| // attributes all together |
| return; |
| } |
| |
| boolean hasWeight = child.hasAttributeNS(ANDROID_URI, ATTR_LAYOUT_WEIGHT); |
| |
| Attr widthNode = child.getAttributeNodeNS(ANDROID_URI, ATTR_LAYOUT_WIDTH); |
| Attr heightNode = child.getAttributeNodeNS(ANDROID_URI, ATTR_LAYOUT_HEIGHT); |
| |
| boolean noWidth = false; |
| boolean noHeight = false; |
| if (widthNode != null && widthNode.getValue().startsWith("0")) { |
| noWidth = true; |
| } |
| if (heightNode != null && heightNode.getValue().startsWith("0")) { |
| noHeight = true; |
| } else if (!noWidth) { |
| return; |
| } |
| |
| if (child.getTagName().equals(SPACE)) { |
| return; |
| } |
| |
| // If you're specifying 0dp for both the width and height you are probably |
| // trying to hide it deliberately |
| if (noWidth && noHeight) { |
| return; |
| } |
| |
| if (noWidth) { |
| if (!hasWeight) { |
| context.report( |
| WRONG_0DP, |
| widthNode, |
| context.getLocation(widthNode), |
| "Suspicious size: this will make the view invisible, should be " |
| + "used with `layout_weight`"); |
| } else if (isVertical) { |
| context.report( |
| WRONG_0DP, |
| widthNode, |
| context.getLocation(widthNode), |
| "Suspicious size: this will make the view invisible, probably " |
| + "intended for `layout_height`"); |
| } |
| } else { |
| if (!hasWeight) { |
| context.report( |
| WRONG_0DP, |
| widthNode, |
| context.getLocation(heightNode), |
| "Suspicious size: this will make the view invisible, should be " |
| + "used with `layout_weight`"); |
| } else if (!isVertical) { |
| context.report( |
| WRONG_0DP, |
| widthNode, |
| context.getLocation(heightNode), |
| "Suspicious size: this will make the view invisible, probably " |
| + "intended for `layout_width`"); |
| } |
| } |
| } |
| } |
| } |
