| /* |
| * 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.ANDROID_URI; |
| import static com.android.SdkConstants.ATTR_DRAWABLE_END; |
| import static com.android.SdkConstants.ATTR_DRAWABLE_LEFT; |
| import static com.android.SdkConstants.ATTR_DRAWABLE_RIGHT; |
| import static com.android.SdkConstants.ATTR_DRAWABLE_START; |
| import static com.android.SdkConstants.ATTR_GRAVITY; |
| import static com.android.SdkConstants.ATTR_LAYOUT_ALIGN_END; |
| import static com.android.SdkConstants.ATTR_LAYOUT_ALIGN_LEFT; |
| import static com.android.SdkConstants.ATTR_LAYOUT_ALIGN_PARENT_END; |
| import static com.android.SdkConstants.ATTR_LAYOUT_ALIGN_PARENT_LEFT; |
| import static com.android.SdkConstants.ATTR_LAYOUT_ALIGN_PARENT_RIGHT; |
| import static com.android.SdkConstants.ATTR_LAYOUT_ALIGN_PARENT_START; |
| import static com.android.SdkConstants.ATTR_LAYOUT_ALIGN_RIGHT; |
| import static com.android.SdkConstants.ATTR_LAYOUT_ALIGN_START; |
| import static com.android.SdkConstants.ATTR_LAYOUT_GRAVITY; |
| import static com.android.SdkConstants.ATTR_LAYOUT_MARGIN; |
| import static com.android.SdkConstants.ATTR_LAYOUT_MARGIN_END; |
| import static com.android.SdkConstants.ATTR_LAYOUT_MARGIN_LEFT; |
| import static com.android.SdkConstants.ATTR_LAYOUT_MARGIN_RIGHT; |
| import static com.android.SdkConstants.ATTR_LAYOUT_MARGIN_START; |
| import static com.android.SdkConstants.ATTR_LAYOUT_TO_END_OF; |
| import static com.android.SdkConstants.ATTR_LAYOUT_TO_LEFT_OF; |
| import static com.android.SdkConstants.ATTR_LAYOUT_TO_RIGHT_OF; |
| import static com.android.SdkConstants.ATTR_LAYOUT_TO_START_OF; |
| import static com.android.SdkConstants.ATTR_LIST_PREFERRED_ITEM_PADDING_END; |
| import static com.android.SdkConstants.ATTR_LIST_PREFERRED_ITEM_PADDING_LEFT; |
| import static com.android.SdkConstants.ATTR_LIST_PREFERRED_ITEM_PADDING_RIGHT; |
| import static com.android.SdkConstants.ATTR_LIST_PREFERRED_ITEM_PADDING_START; |
| import static com.android.SdkConstants.ATTR_PADDING; |
| import static com.android.SdkConstants.ATTR_PADDING_END; |
| import static com.android.SdkConstants.ATTR_PADDING_LEFT; |
| import static com.android.SdkConstants.ATTR_PADDING_RIGHT; |
| import static com.android.SdkConstants.ATTR_PADDING_START; |
| import static com.android.SdkConstants.GRAVITY_VALUE_END; |
| import static com.android.SdkConstants.GRAVITY_VALUE_LEFT; |
| import static com.android.SdkConstants.GRAVITY_VALUE_RIGHT; |
| import static com.android.SdkConstants.GRAVITY_VALUE_START; |
| import static com.android.SdkConstants.TAG_APPLICATION; |
| |
| import com.android.annotations.NonNull; |
| import com.android.annotations.Nullable; |
| import com.android.annotations.VisibleForTesting; |
| import com.android.tools.lint.client.api.JavaParser; |
| import com.android.tools.lint.detector.api.Category; |
| import com.android.tools.lint.detector.api.Context; |
| import com.android.tools.lint.detector.api.Detector; |
| 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.LayoutDetector; |
| import com.android.tools.lint.detector.api.LintUtils; |
| import com.android.tools.lint.detector.api.Location; |
| import com.android.tools.lint.detector.api.Project; |
| 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 org.w3c.dom.Attr; |
| import org.w3c.dom.Element; |
| |
| import java.io.File; |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.EnumSet; |
| import java.util.List; |
| import java.util.Locale; |
| |
| import lombok.ast.AstVisitor; |
| import lombok.ast.EnumConstant; |
| import lombok.ast.ForwardingAstVisitor; |
| import lombok.ast.Identifier; |
| import lombok.ast.ImportDeclaration; |
| import lombok.ast.Node; |
| import lombok.ast.Select; |
| import lombok.ast.VariableDefinitionEntry; |
| import lombok.ast.VariableReference; |
| |
| /** |
| * Check which looks for RTL issues (right-to-left support) in layouts |
| */ |
| public class RtlDetector extends LayoutDetector implements Detector.JavaScanner { |
| |
| @SuppressWarnings("unchecked") |
| private static final Implementation IMPLEMENTATION = new Implementation( |
| RtlDetector.class, |
| EnumSet.of(Scope.RESOURCE_FILE, Scope.JAVA_FILE, Scope.MANIFEST), |
| Scope.RESOURCE_FILE_SCOPE, |
| Scope.JAVA_FILE_SCOPE, |
| Scope.MANIFEST_SCOPE |
| ); |
| |
| public static final Issue USE_START = Issue.create( |
| "RtlHardcoded", //$NON-NLS-1$ |
| "Using left/right instead of start/end attributes", |
| |
| "Using `Gravity#LEFT` and `Gravity#RIGHT` can lead to problems when a layout is " + |
| "rendered in locales where text flows from right to left. Use `Gravity#START` " + |
| "and `Gravity#END` instead. Similarly, in XML `gravity` and `layout_gravity` " + |
| "attributes, use `start` rather than `left`.\n" + |
| "\n" + |
| "For XML attributes such as paddingLeft and `layout_marginLeft`, use `paddingStart` " + |
| "and `layout_marginStart`. *NOTE*: If your `minSdkVersion` is less than 17, you should " + |
| "add *both* the older left/right attributes *as well as* the new start/right " + |
| "attributes. On older platforms, where RTL is not supported and the start/right " + |
| "attributes are unknown and therefore ignored, you need the older left/right " + |
| "attributes. There is a separate lint check which catches that type of error.\n" + |
| "\n" + |
| "(Note: For `Gravity#LEFT` and `Gravity#START`, you can use these constants even " + |
| "when targeting older platforms, because the `start` bitmask is a superset of the " + |
| "`left` bitmask. Therefore, you can use `gravity=\"start\"` rather than " + |
| "`gravity=\"left|start\"`.)", |
| |
| Category.RTL, 5, Severity.WARNING, IMPLEMENTATION); |
| |
| public static final Issue COMPAT = Issue.create( |
| "RtlCompat", //$NON-NLS-1$ |
| "Right-to-left text compatibility issues", |
| |
| "API 17 adds a `textAlignment` attribute to specify text alignment. However, " + |
| "if you are supporting older versions than API 17, you must *also* specify a " + |
| "gravity or layout_gravity attribute, since older platforms will ignore the " + |
| "`textAlignment` attribute.", |
| |
| Category.RTL, 6, Severity.ERROR, IMPLEMENTATION); |
| |
| public static final Issue SYMMETRY = Issue.create( |
| "RtlSymmetry", //$NON-NLS-1$ |
| "Padding and margin symmetry", |
| |
| "If you specify padding or margin on the left side of a layout, you should " + |
| "probably also specify padding on the right side (and vice versa) for " + |
| "right-to-left layout symmetry.", |
| |
| Category.RTL, 6, Severity.WARNING, IMPLEMENTATION); |
| |
| |
| public static final Issue ENABLED = Issue.create( |
| "RtlEnabled", //$NON-NLS-1$ |
| "Using RTL attributes without enabling RTL support", |
| |
| "To enable right-to-left support, when running on API 17 and higher, you must " + |
| "set the `android:supportsRtl` attribute in the manifest `<application>` element.\n" + |
| "\n" + |
| "If you have started adding RTL attributes, but have not yet finished the " + |
| "migration, you can set the attribute to false to satisfy this lint check.", |
| |
| Category.RTL, 3, Severity.WARNING, IMPLEMENTATION); |
| |
| /* TODO: |
| public static final Issue FIELD = Issue.create( |
| "RtlFieldAccess", //$NON-NLS-1$ |
| "Accessing margin and padding fields directly", |
| |
| "Modifying the padding and margin constants in view objects directly is " + |
| "problematic when using RTL support, since it can lead to inconsistent states. You " + |
| "*must* use the corresponding setter methods instead (`View#setPadding` etc).", |
| |
| Category.RTL, 3, Severity.WARNING, IMPLEMENTATION).setEnabledByDefault(false); |
| |
| public static final Issue AWARE = Issue.create( |
| "RtlAware", //$NON-NLS-1$ |
| "View code not aware of RTL APIs", |
| |
| "When manipulating views, and especially when implementing custom layouts, " + |
| "the code may need to be aware of RTL APIs. This lint check looks for usages of " + |
| "APIs that frequently require adjustments for right-to-left text, and warns if it " + |
| "does not also see text direction look-ups indicating that the code has already " + |
| "been updated to handle RTL layouts.", |
| |
| Category.RTL, 3, Severity.WARNING, IMPLEMENTATION).setEnabledByDefault(false); |
| */ |
| |
| private static final String RIGHT_FIELD = "RIGHT"; //$NON-NLS-1$ |
| private static final String LEFT_FIELD = "LEFT"; //$NON-NLS-1$ |
| private static final String GRAVITY_CLASS = "Gravity"; //$NON-NLS-1$ |
| private static final String FQCN_GRAVITY = "android.view.Gravity"; //$NON-NLS-1$ |
| private static final String FQCN_GRAVITY_PREFIX = "android.view.Gravity."; //$NON-NLS-1$ |
| private static final String ATTR_SUPPORTS_RTL = "supportsRtl"; //$NON-NLS-1$ |
| private static final String ATTR_TEXT_ALIGNMENT = "textAlignment"; //$NON-NLS-1$ |
| |
| /** API version in which RTL support was added */ |
| private static final int RTL_API = 17; |
| |
| private static final String LEFT = "Left"; |
| private static final String START = "Start"; |
| private static final String RIGHT = "Right"; |
| private static final String END = "End"; |
| |
| private Boolean mEnabledRtlSupport; |
| private boolean mUsesRtlAttributes; |
| |
| /** Constructs a new {@link RtlDetector} */ |
| public RtlDetector() { |
| } |
| |
| @Override |
| @NonNull |
| public Speed getSpeed() { |
| return Speed.NORMAL; |
| } |
| |
| private boolean rtlApplies(@NonNull Context context) { |
| Project project = context.getMainProject(); |
| if (project.getTargetSdk() < RTL_API) { |
| return false; |
| } |
| |
| int buildTarget = project.getBuildSdk(); |
| if (buildTarget != -1 && buildTarget < RTL_API) { |
| return false; |
| } |
| |
| //noinspection RedundantIfStatement |
| if (mEnabledRtlSupport != null && !mEnabledRtlSupport) { |
| return false; |
| } |
| |
| return true; |
| } |
| |
| @Override |
| public void afterCheckProject(@NonNull Context context) { |
| if (mUsesRtlAttributes && mEnabledRtlSupport == null && rtlApplies(context)) { |
| List<File> manifestFile = context.getMainProject().getManifestFiles(); |
| if (!manifestFile.isEmpty()) { |
| Location location = Location.create(manifestFile.get(0)); |
| context.report(ENABLED, location, |
| "The project references RTL attributes, but does not explicitly enable " + |
| "or disable RTL support with `android:supportsRtl` in the manifest"); |
| } |
| } |
| } |
| |
| // ---- Implements XmlDetector ---- |
| |
| @VisibleForTesting |
| static final String[] ATTRIBUTES = new String[] { |
| // Pairs, from left/right constants to corresponding start/end constants |
| ATTR_LAYOUT_ALIGN_PARENT_LEFT, ATTR_LAYOUT_ALIGN_PARENT_START, |
| ATTR_LAYOUT_ALIGN_PARENT_RIGHT, ATTR_LAYOUT_ALIGN_PARENT_END, |
| ATTR_LAYOUT_MARGIN_LEFT, ATTR_LAYOUT_MARGIN_START, |
| ATTR_LAYOUT_MARGIN_RIGHT, ATTR_LAYOUT_MARGIN_END, |
| ATTR_PADDING_LEFT, ATTR_PADDING_START, |
| ATTR_PADDING_RIGHT, ATTR_PADDING_END, |
| ATTR_DRAWABLE_LEFT, ATTR_DRAWABLE_START, |
| ATTR_DRAWABLE_RIGHT, ATTR_DRAWABLE_END, |
| ATTR_LIST_PREFERRED_ITEM_PADDING_LEFT, ATTR_LIST_PREFERRED_ITEM_PADDING_START, |
| ATTR_LIST_PREFERRED_ITEM_PADDING_RIGHT, ATTR_LIST_PREFERRED_ITEM_PADDING_END, |
| |
| // RelativeLayout |
| ATTR_LAYOUT_TO_LEFT_OF, ATTR_LAYOUT_TO_START_OF, |
| ATTR_LAYOUT_TO_RIGHT_OF, ATTR_LAYOUT_TO_END_OF, |
| ATTR_LAYOUT_ALIGN_LEFT, ATTR_LAYOUT_ALIGN_START, |
| ATTR_LAYOUT_ALIGN_RIGHT, ATTR_LAYOUT_ALIGN_END, |
| }; |
| static { |
| if (LintUtils.assertionsEnabled()) { |
| for (int i = 0; i < ATTRIBUTES.length; i += 2) { |
| String replace = ATTRIBUTES[i]; |
| String with = ATTRIBUTES[i + 1]; |
| assert with.equals(convertOldToNew(replace)); |
| assert replace.equals(convertNewToOld(with)); |
| } |
| } |
| } |
| |
| public static boolean isRtlAttributeName(@NonNull String attribute) { |
| for (int i = 1; i < ATTRIBUTES.length; i += 2) { |
| if (attribute.equals(ATTRIBUTES[i])) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| @VisibleForTesting |
| static String convertOldToNew(String attribute) { |
| if (attribute.contains(LEFT)) { |
| return attribute.replace(LEFT, START); |
| } else { |
| return attribute.replace(RIGHT, END); |
| } |
| } |
| |
| @VisibleForTesting |
| static String convertNewToOld(String attribute) { |
| if (attribute.contains(START)) { |
| return attribute.replace(START, LEFT); |
| } else { |
| return attribute.replace(END, RIGHT); |
| } |
| } |
| |
| @VisibleForTesting |
| static String convertToOppositeDirection(String attribute) { |
| if (attribute.contains(LEFT)) { |
| return attribute.replace(LEFT, RIGHT); |
| } else if (attribute.contains(RIGHT)) { |
| return attribute.replace(RIGHT, LEFT); |
| } else if (attribute.contains(START)) { |
| return attribute.replace(START, END); |
| } else { |
| return attribute.replace(END, START); |
| } |
| } |
| |
| @Nullable |
| static String getTextAlignmentToGravity(String attribute) { |
| if (attribute.endsWith(START)) { // textStart, viewStart, ... |
| return GRAVITY_VALUE_START; |
| } else if (attribute.endsWith(END)) { // textEnd, viewEnd, ... |
| return GRAVITY_VALUE_END; |
| } else { |
| return null; // inherit, others |
| } |
| } |
| |
| @Override |
| public Collection<String> getApplicableAttributes() { |
| int size = ATTRIBUTES.length + 4; |
| List<String> attributes = new ArrayList<String>(size); |
| |
| // For detecting whether RTL support is enabled |
| attributes.add(ATTR_SUPPORTS_RTL); |
| |
| // For detecting left/right attributes which should probably be |
| // migrated to start/end |
| attributes.add(ATTR_GRAVITY); |
| attributes.add(ATTR_LAYOUT_GRAVITY); |
| |
| // For detecting existing attributes which indicate an attempt to |
| // use RTL |
| attributes.add(ATTR_TEXT_ALIGNMENT); |
| |
| // Add conversion attributes: left/right attributes to nominate |
| // attributes that should be added as start/end, and start/end |
| // attributes to use to look up elements that should have compatibility |
| // left/right ones as well |
| Collections.addAll(attributes, ATTRIBUTES); |
| |
| assert attributes.size() == size : attributes.size(); |
| |
| return attributes; |
| } |
| |
| @Override |
| public void visitAttribute(@NonNull XmlContext context, @NonNull Attr attribute) { |
| Project project = context.getMainProject(); |
| String value = attribute.getValue(); |
| |
| if (!ANDROID_URI.equals(attribute.getNamespaceURI())) { |
| // Layout attribute not in the Android namespace (or a custom namespace). |
| // This is likely an application error (which should get caught by |
| // the MissingPrefixDetector) |
| return; |
| } |
| |
| String name = attribute.getLocalName(); |
| assert name != null : attribute.getName(); |
| |
| if (name.equals(ATTR_SUPPORTS_RTL)) { |
| mEnabledRtlSupport = Boolean.valueOf(value); |
| if (!attribute.getOwnerElement().getTagName().equals(TAG_APPLICATION)) { |
| context.report(ENABLED, attribute, context.getLocation(attribute), String.format( |
| "Wrong declaration: `%1$s` should be defined on the `<application>` element", |
| attribute.getName())); |
| } |
| int targetSdk = project.getTargetSdk(); |
| if (mEnabledRtlSupport && targetSdk < RTL_API) { |
| String message = String.format( |
| "You must set `android:targetSdkVersion` to at least %1$d when " |
| + "enabling RTL support (is %2$d)", |
| RTL_API, project.getTargetSdk()); |
| context.report(ENABLED, attribute, context.getValueLocation(attribute), message); |
| } |
| return; |
| } |
| |
| if (!rtlApplies(context)) { |
| return; |
| } |
| |
| if (name.equals(ATTR_TEXT_ALIGNMENT)) { |
| if (context.getProject().getReportIssues()) { |
| mUsesRtlAttributes = true; |
| } |
| |
| Element element = attribute.getOwnerElement(); |
| final String gravity; |
| final Attr gravityNode; |
| if (element.hasAttributeNS(ANDROID_URI, ATTR_GRAVITY)) { |
| gravityNode = element.getAttributeNodeNS(ANDROID_URI, ATTR_GRAVITY); |
| gravity = gravityNode.getValue(); |
| } else if (element.hasAttributeNS(ANDROID_URI, ATTR_LAYOUT_GRAVITY)) { |
| gravityNode = element.getAttributeNodeNS(ANDROID_URI, ATTR_LAYOUT_GRAVITY); |
| gravity = gravityNode.getValue(); |
| } else if (project.getMinSdk() < RTL_API) { |
| int folderVersion = context.getFolderVersion(); |
| if (folderVersion < RTL_API && context.isEnabled(COMPAT)) { |
| String expectedGravity = getTextAlignmentToGravity(value); |
| if (expectedGravity != null) { |
| String message = String.format( |
| "To support older versions than API 17 (project specifies %1$d) " |
| + "you must *also* specify `gravity` or `layout_gravity=\"%2$s\"`", |
| project.getMinSdk(), expectedGravity); |
| context.report(COMPAT, attribute, |
| context.getNameLocation(attribute), message); |
| } |
| } |
| return; |
| } else { |
| return; |
| } |
| |
| String expectedGravity = getTextAlignmentToGravity(value); |
| if (expectedGravity != null && !gravity.contains(expectedGravity) |
| && context.isEnabled(COMPAT)) { |
| String message = String.format("Inconsistent alignment specification between " |
| + "`textAlignment` and `gravity` attributes: was `%1$s`, expected `%2$s`", |
| gravity, expectedGravity); |
| Location location = context.getValueLocation(attribute); |
| context.report(COMPAT, attribute, location, message); |
| Location secondary = context.getValueLocation(gravityNode); |
| secondary.setMessage("Incompatible direction here"); |
| location.setSecondary(secondary); |
| } |
| return; |
| } |
| |
| if (name.equals(ATTR_GRAVITY) || name.equals(ATTR_LAYOUT_GRAVITY)) { |
| boolean isLeft = value.contains(GRAVITY_VALUE_LEFT); |
| boolean isRight = value.contains(GRAVITY_VALUE_RIGHT); |
| if (!isLeft && !isRight) { |
| if ((value.contains(GRAVITY_VALUE_START) || value.contains(GRAVITY_VALUE_END)) |
| && context.getProject().getReportIssues()) { |
| mUsesRtlAttributes = true; |
| } |
| return; |
| } |
| String message = String.format( |
| "Use \"`%1$s`\" instead of \"`%2$s`\" to ensure correct behavior in " |
| + "right-to-left locales", |
| isLeft ? GRAVITY_VALUE_START : GRAVITY_VALUE_END, |
| isLeft ? GRAVITY_VALUE_LEFT : GRAVITY_VALUE_RIGHT); |
| if (context.isEnabled(USE_START)) { |
| context.report(USE_START, attribute, context.getValueLocation(attribute), message); |
| } |
| |
| return; |
| } |
| |
| // Some other left/right/start/end attribute |
| int targetSdk = project.getTargetSdk(); |
| |
| // TODO: If attribute is drawableLeft or drawableRight, add note that you might |
| // want to consider adding a specialized image in the -ldrtl folder as well |
| |
| Element element = attribute.getOwnerElement(); |
| boolean isPaddingAttribute = isPaddingAttribute(name); |
| if (isPaddingAttribute || isMarginAttribute(name)) { |
| String opposite = convertToOppositeDirection(name); |
| if (element.hasAttributeNS(ANDROID_URI, opposite)) { |
| String oldValue = element.getAttributeNS(ANDROID_URI, opposite); |
| if (value.equals(oldValue)) { |
| return; |
| } |
| } else if (isPaddingAttribute |
| && !element.hasAttributeNS(ANDROID_URI, |
| isOldAttribute(opposite) ? convertOldToNew(opposite) |
| : convertNewToOld(opposite)) && context.isEnabled(SYMMETRY)) { |
| String message = String.format( |
| "When you define `%1$s` you should probably also define `%2$s` for " |
| + "right-to-left symmetry", name, opposite); |
| context.report(SYMMETRY, attribute, context.getNameLocation(attribute), message); |
| } |
| } |
| |
| boolean isOld = isOldAttribute(name); |
| if (isOld) { |
| if (!context.isEnabled(USE_START)) { |
| return; |
| } |
| String rtl = convertOldToNew(name); |
| if (element.hasAttributeNS(ANDROID_URI, rtl)) { |
| if (project.getMinSdk() >= RTL_API || context.getFolderVersion() >= RTL_API) { |
| // Warn that left/right isn't needed |
| String message = String.format( |
| "Redundant attribute `%1$s`; already defining `%2$s` with " |
| + "`targetSdkVersion` %3$s", |
| name, rtl, targetSdk); |
| context.report(USE_START, attribute, |
| context.getNameLocation(attribute), message); |
| } |
| } else { |
| String message; |
| if (project.getMinSdk() >= RTL_API || context.getFolderVersion() >= RTL_API) { |
| message = String.format( |
| "Consider replacing `%1$s` with `%2$s:%3$s=\"%4$s\"` to better support " |
| + "right-to-left layouts", |
| attribute.getName(), attribute.getPrefix(), rtl, value); |
| } else { |
| message = String.format( |
| "Consider adding `%1$s:%2$s=\"%3$s\"` to better support " |
| + "right-to-left layouts", |
| attribute.getPrefix(), rtl, value); |
| } |
| context.report(USE_START, attribute, |
| context.getNameLocation(attribute), message); |
| } |
| } else { |
| if (project.getMinSdk() >= RTL_API || !context.isEnabled(COMPAT)) { |
| // Only supporting 17+: no need to define older attributes |
| return; |
| } |
| int folderVersion = context.getFolderVersion(); |
| if (folderVersion >= RTL_API) { |
| // In a -v17 folder or higher: no need to define older attributes |
| return; |
| } |
| String old = convertNewToOld(name); |
| if (element.hasAttributeNS(ANDROID_URI, old)) { |
| return; |
| } |
| String message = String.format( |
| "To support older versions than API 17 (project specifies %1$d) " |
| + "you should *also* add `%2$s:%3$s=\"%4$s\"`", |
| project.getMinSdk(), attribute.getPrefix(), old, |
| convertNewToOld(value)); |
| context.report(COMPAT, attribute, context.getNameLocation(attribute), message); |
| } |
| } |
| |
| private static boolean isOldAttribute(String name) { |
| return name.contains(LEFT) || name.contains(RIGHT); |
| } |
| |
| private static boolean isMarginAttribute(@NonNull String name) { |
| return name.startsWith(ATTR_LAYOUT_MARGIN); |
| } |
| |
| private static boolean isPaddingAttribute(@NonNull String name) { |
| return name.startsWith(ATTR_PADDING); |
| } |
| |
| // ---- Implements JavaScanner ---- |
| |
| @Override |
| public boolean appliesTo(@NonNull Context context, @NonNull File file) { |
| return true; |
| } |
| |
| @Override |
| public List<Class<? extends Node>> getApplicableNodeTypes() { |
| return Collections.<Class<? extends Node>>singletonList(Identifier.class); |
| } |
| |
| @Override |
| public AstVisitor createJavaVisitor(@NonNull JavaContext context) { |
| if (rtlApplies(context)) { |
| return new IdentifierChecker(context); |
| } |
| |
| return new ForwardingAstVisitor() { }; |
| } |
| |
| private static class IdentifierChecker extends ForwardingAstVisitor { |
| private final JavaContext mContext; |
| |
| public IdentifierChecker(JavaContext context) { |
| mContext = context; |
| } |
| |
| @Override |
| public boolean visitIdentifier(Identifier node) { |
| String identifier = node.astValue(); |
| boolean isLeft = LEFT_FIELD.equals(identifier); |
| boolean isRight = RIGHT_FIELD.equals(identifier); |
| if (!isLeft && !isRight) { |
| return false; |
| } |
| |
| Node parent = node.getParent(); |
| if (parent instanceof ImportDeclaration || parent instanceof EnumConstant |
| || parent instanceof VariableDefinitionEntry) { |
| return false; |
| } |
| |
| JavaParser.ResolvedNode resolved = mContext.resolve(node); |
| if (resolved != null) { |
| if (!(resolved instanceof JavaParser.ResolvedField)) { |
| return false; |
| } else { |
| JavaParser.ResolvedField field = (JavaParser.ResolvedField) resolved; |
| if (!field.getContainingClass().matches(FQCN_GRAVITY)) { |
| return false; |
| } |
| } |
| } else { |
| // Can't resolve types (for example while editing code with errors): |
| // rely on heuristics like import statements and class qualifiers |
| if (parent instanceof Select && |
| !(GRAVITY_CLASS.equals(((Select) parent).astOperand().toString()))) { |
| return false; |
| } |
| if (parent instanceof VariableReference) { |
| // No operand: make sure it's statically imported |
| if (!LintUtils.isImported(mContext.getCompilationUnit(), |
| FQCN_GRAVITY_PREFIX + identifier)) { |
| return false; |
| } |
| } |
| } |
| |
| String message = String.format( |
| "Use \"`Gravity.%1$s`\" instead of \"`Gravity.%2$s`\" to ensure correct " |
| + "behavior in right-to-left locales", |
| (isLeft ? GRAVITY_VALUE_START : GRAVITY_VALUE_END).toUpperCase(Locale.US), |
| (isLeft ? GRAVITY_VALUE_LEFT : GRAVITY_VALUE_RIGHT).toUpperCase(Locale.US)); |
| Location location = mContext.getLocation(node); |
| mContext.report(USE_START, node, location, message); |
| |
| return true; |
| } |
| } |
| } |
