Polishing custom lint rules sample naming, comments, and use of LintUtils.

grant · grant · commit 499d2b30a38f · 2015-08-25T12:55:37.000-07:00
- Using Collections.singleton(List) where appropriate
- Clarify meaning of 'main activity'
- Use LintUtils
- Formatting

Change-Id: Iab1a82f619e103cf6401f68c36704402f6c87252
diff --git a/README.md b/README.md
@@ -4,7 +4,7 @@ Custom Lint Rules
 The [Android `lint` tool](http://developer.android.com/tools/help/lint.html) is a static code
  analysis tool that checks your Android project source files for potential bugs and optimization
  improvements for correctness, security, performance, usability, accessibility, and
- internationalization. Lint comes with over 100 checks, however it can be extended with additional
+ internationalization. Lint comes with over 200 checks, however it can be extended with additional
  custom rules.
 
 **NOTE: The lint API is not a final API; if you rely on this be prepared
@@ -42,7 +42,7 @@ Getting Started
 
 ##### Run lint
 
-`lint`
+`./gradlew lint`
 
 > Note: If you can't run `lint` directly, you may want to include android tools `PATH` in your
  `~/.bash_profile`.
diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
@@ -1,6 +1,6 @@
-#Wed Apr 10 15:27:10 PDT 2013
+#Fri Aug 21 14:39:26 PDT 2015
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-2.2.1-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-2.4-all.zip
diff --git a/src/main/java/com/example/google/lint/MainActivityDetector.java b/src/main/java/com/example/google/lint/MainActivityDetector.java
@@ -22,6 +22,7 @@
 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.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;
@@ -30,10 +31,10 @@
 
 import org.w3c.dom.Element;
 import org.w3c.dom.Node;
-import org.w3c.dom.NodeList;
 
-import java.util.Arrays;
+import java.io.File;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.EnumSet;
 
 import static com.android.SdkConstants.ANDROID_MANIFEST_XML;
@@ -44,18 +45,20 @@
 import static com.android.SdkConstants.TAG_INTENT_FILTER;
 import static com.android.xml.AndroidManifest.NODE_ACTION;
 import static com.android.xml.AndroidManifest.NODE_CATEGORY;
+import static com.example.google.lint.ManifestConstants.ACTION_NAME_MAIN;
+import static com.example.google.lint.ManifestConstants.CATEGORY_NAME_LAUNCHER;
 
 /**
- * Checks for a main activity in <code>AndroidManifest.xml</code>.
+ * Checks for an activity with a launcher intent in <code>AndroidManifest.xml</code>.
  * <p/>
  * <b>NOTE: This is not a final API; if you rely on this be prepared
  * to adjust your code for the next tools release.</b>
  */
 public class MainActivityDetector extends ResourceXmlDetector implements Detector.XmlScanner {
     public static final Issue ISSUE = Issue.create(
             "MainActivityDetector",
-            "Checks for a main activity",
-            "This app should have a main launcher activity.",
+            "Missing Launcher Activities",
+            "This app should have an activity with a launcher intent.",
             Category.CORRECTNESS,
             8,
             Severity.ERROR,
@@ -64,102 +67,103 @@ public class MainActivityDetector extends ResourceXmlDetector implements Detecto
                     EnumSet.of(Scope.MANIFEST)));
 
     /**
-     * Will be <code>true</code> if the current file we're checking has at least one activity.
+     * This will be <code>true</code> if the current file we're checking has at least one activity.
      */
     private boolean mHasActivity;
     /**
-     * Will be <code>true</code> if the file has a main activity.
+     * This will be <code>true</code> if the file has an activity with a launcher intent.
      */
-    private boolean mHasMainActivity;
+    private boolean mHasLauncherActivity;
+    /**
+     * The manifest file location for the main project, <code>null</code> if there is no manifest.
+     */
+    private Location mManifestLocation;
+
+    /**
+     * No-args constructor used by the lint framework to instantiate the detector.
+     */
+    public MainActivityDetector() {
+    }
 
     @Override
     public Collection<String> getApplicableElements() {
-        return Arrays.asList(
-                TAG_ACTIVITY
-        );
+        return Collections.singleton(TAG_ACTIVITY);
     }
 
     @Override
-    public void beforeCheckFile(@NonNull Context context) {
+    public void beforeCheckProject(@NonNull Context context) {
         mHasActivity = false;
-        mHasMainActivity = false;
+        mHasLauncherActivity = false;
+        mManifestLocation = null;
+    }
+
+    @Override
+    public void afterCheckProject(@NonNull Context context) {
+        // Don't report issues on libraries that may not have a launcher activity
+        if (context.getProject() == context.getMainProject()
+                && !context.getMainProject().isLibrary()
+                && mManifestLocation != null) {
+            if (!mHasActivity) {
+                context.report(ISSUE, mManifestLocation,
+                        "Expecting " + ANDROID_MANIFEST_XML + " to have an <" + TAG_APPLICATION +
+                                "> tag.");
+            } else if (!mHasLauncherActivity) {
+                // Report the issue if the manifest file has no activity with a launcher intent.
+                context.report(ISSUE, mManifestLocation,
+                        "Expecting " + ANDROID_MANIFEST_XML +
+                                " to have an activity with a launcher intent.");
+            }
+        }
     }
 
     @Override
     public void afterCheckFile(@NonNull Context context) {
-        // Report an error if there are no <application> tags to check.
-        // We assume the application tag is in the right place (i.e. have correct parent elements).
-        Location location = Location.create(context.file);
-        if (!mHasActivity) {
-            context.report(ISSUE, location,
-                    "Expecting " + ANDROID_MANIFEST_XML + " to have an <" + TAG_APPLICATION +
-                            "> tag.");
-        } else if (!mHasMainActivity) {
-            // Report the issue if the manifest file has no main activity.
-            context.report(ISSUE, location,
-                    "Expecting " + ANDROID_MANIFEST_XML + " to have a main activity.");
+        // Store a reference to the manifest file in case we need to report it's location.
+        if (context.getProject() == context.getMainProject()) {
+            mManifestLocation = Location.create(context.file);
         }
     }
 
     @Override
     public void visitElement(XmlContext context, Element activityElement) {
-        // Checks every activity under the <application> element and reports an error if there is
-        // no main activity.
+        // Checks every activity and reports an error if there is no activity with a launcher
+        // intent.
         mHasActivity = true;
         if (isMainActivity(activityElement)) {
-            mHasMainActivity = true;
+            mHasLauncherActivity = true;
         }
     }
 
     /**
-     * Returns true if the XML node is a main activity.
-     * <p/>
-     * A main activity is an <code>&lt;activity&gt;</code> node with an <code>&lt;
-     * intent-filter&gt;</code> that contains the following tags:
-     * <p/>
-     * <pre>
-     *   <category android:name="android.intent.category.LAUNCHER" />
-     *   <action android:name="android.intent.action.MAIN" />
-     * </pre>
+     * Returns true if the XML node is an activity with a launcher intent.
      *
      * @param activityNode The node to check.
-     * @return <code>true</code> if the node is a main activity.
+     * @return <code>true</code> if the node is an activity with a launcher intent.
      */
     private boolean isMainActivity(Node activityNode) {
         if (TAG_ACTIVITY.equals(activityNode.getNodeName())) {
             // Loop through all <intent-filter> tags
-            NodeList activityChildren = activityNode.getChildNodes();
-            for (int i = 0; i < activityChildren.getLength(); ++i) {
-                Node activityChild = activityChildren.item(i);
+            for (Element activityChild : LintUtils.getChildren(activityNode)) {
                 if (TAG_INTENT_FILTER.equals(activityChild.getNodeName())) {
-                    NodeList intentFilterChildren = activityChild.getChildNodes();
-
                     // Check for these children nodes:
                     //
                     // <category android:name="android.intent.category.LAUNCHER" />
                     // <action android:name="android.intent.action.MAIN" />
                     boolean hasLauncherCategory = false;
                     boolean hasMainAction = false;
 
-                    for (int j = 0; j < intentFilterChildren.getLength(); ++j) {
-                        Node intentFilterChild = intentFilterChildren.item(j);
-                        // Check for category tag
-                        if (NODE_CATEGORY.equals(intentFilterChild.getNodeName())) {
-                            Node categoryName = intentFilterChild.getAttributes()
-                                    .getNamedItemNS(ANDROID_URI, ATTR_NAME);
-                            if (categoryName != null && categoryName.getNodeValue().equals(
-                                    ManifestConstants.CATEGORY_NAME_LAUNCHER)) {
-                                hasLauncherCategory = true;
-                            }
+                    for (Element intentFilterChild : LintUtils.getChildren(activityChild)) {
+                        // Check for category tag)
+                        if (NODE_CATEGORY.equals(intentFilterChild.getNodeName())
+                                && CATEGORY_NAME_LAUNCHER.equals(
+                                intentFilterChild.getAttributeNS(ANDROID_URI, ATTR_NAME))) {
+                            hasLauncherCategory = true;
                         }
                         // Check for action tag
-                        if (NODE_ACTION.equals(intentFilterChild.getNodeName())) {
-                            Node actionName = intentFilterChild.getAttributes()
-                                    .getNamedItemNS(ANDROID_URI, ATTR_NAME);
-                            if (actionName != null && actionName.getNodeValue().equals(
-                                    ManifestConstants.ACTION_NAME_MAIN)) {
-                                hasMainAction = true;
-                            }
+                        if (NODE_ACTION.equals(intentFilterChild.getNodeName())
+                                && ACTION_NAME_MAIN.equals(
+                                intentFilterChild.getAttributeNS(ANDROID_URI, ATTR_NAME))) {
+                            hasMainAction = true;
                         }
                     }
 
diff --git a/src/main/java/com/example/google/lint/MyIssueRegistry.java b/src/main/java/com/example/google/lint/MyIssueRegistry.java
@@ -29,8 +29,6 @@
 public class MyIssueRegistry extends IssueRegistry {
     @Override
     public List<Issue> getIssues() {
-        return Collections.singletonList(
-                MainActivityDetector.ISSUE
-        );
+        return Collections.singletonList(MainActivityDetector.ISSUE);
     }
 }
diff --git a/src/test/java/com/example/google/lint/MainActivityDetectorTest.java b/src/test/java/com/example/google/lint/MainActivityDetectorTest.java
@@ -23,7 +23,6 @@
 import com.android.tools.lint.detector.api.Issue;
 import com.android.tools.lint.detector.api.Project;
 
-import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
@@ -48,9 +47,7 @@ protected Detector getDetector() {
 
     @Override
     protected List<Issue> getIssues() {
-        return Arrays.asList(
-                MainActivityDetector.ISSUE
-        );
+        return Collections.singletonList(MainActivityDetector.ISSUE);
     }
 
     /**
@@ -68,7 +65,7 @@ public boolean isEnabled(@NonNull Issue issue) {
     }
 
     /**
-     * Test that a manifest with a main activity has no warnings.
+     * Test that a manifest with an activity with a launcher intent has no warnings.
      */
     public void testHasMainActivity() throws Exception {
         mEnabled = Collections.singleton(MainActivityDetector.ISSUE);
@@ -95,12 +92,12 @@ public void testHasMainActivity() throws Exception {
     }
 
     /**
-     * Test that a manifest <em>without</em> a main activity reports an error.
+     * Test that a manifest <em>without</em> an activity with a launcher intent reports an error.
      */
     public void testMissingMainActivity() throws Exception {
         mEnabled = Collections.singleton(MainActivityDetector.ISSUE);
-        String expected = "AndroidManifest.xml: Error: Expecting AndroidManifest.xml to have a " +
-                "main activity. [MainActivityDetector]\n" +
+        String expected = "AndroidManifest.xml: Error: Expecting AndroidManifest.xml to have an " +
+                "activity with a launcher intent. [MainActivityDetector]\n" +
                 "1 errors, 0 warnings\n";
         String result = lintProject(xml(FN_ANDROID_MANIFEST_XML, "" +
                 "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n" +

Original file line number	Diff line number	Diff line change
`@@ -29,8 +29,6 @@`
`29`	`29`	`public class MyIssueRegistry extends IssueRegistry {`
`30`	`30`	`@Override`
`31`	`31`	`public List<Issue> getIssues() {`
`32`		`- return Collections.singletonList(`
`33`		`- MainActivityDetector.ISSUE`
`34`		`- );`
	`32`	`+ return Collections.singletonList(MainActivityDetector.ISSUE);`
`35`	`33`	`}`
`36`	`34`	`}`