diff options
-rw-r--r-- | AccessCheck/src/com/android/accessibility/AccessibilityValidationContentHandler.java | 214 | ||||
-rw-r--r-- | AccessCheck/src/com/android/accessibility/AccessibilityValidator.java | 191 | ||||
-rw-r--r-- | Android.mk | 27 | ||||
-rwxr-xr-x | MODULE_LICENSE_APACHE2 | 0 | ||||
-rwxr-xr-x | NOTICE | 190 |
5 files changed, 622 insertions, 0 deletions
diff --git a/AccessCheck/src/com/android/accessibility/AccessibilityValidationContentHandler.java b/AccessCheck/src/com/android/accessibility/AccessibilityValidationContentHandler.java new file mode 100644 index 0000000..77d67f0 --- /dev/null +++ b/AccessCheck/src/com/android/accessibility/AccessibilityValidationContentHandler.java @@ -0,0 +1,214 @@ +/* + * Copyright 2010 Google Inc. + * + * 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.accessibility; + +import org.xml.sax.Attributes; +import org.xml.sax.Locator; +import org.xml.sax.helpers.DefaultHandler; + +import java.io.File; +import java.net.MalformedURLException; +import java.net.URL; +import java.net.URLClassLoader; +import java.util.ArrayList; +import java.util.HashSet; +import java.util.List; +import java.util.Set; +import java.util.logging.Logger; + +/** + * An object that handles Android xml layout files in conjunction with an + * XMLParser for the purpose of testing for accessibility based on the following + * rule: + * <p> + * If the Element tag is ImageView (or a subclass of ImageView), then the tag + * must contain a contentDescription attribute. + * <p> + * This class also has logic to ascertain the subclasses of ImageView and thus + * requires the path to an Android sdk jar. The subclasses are saved for + * application of the above rule when a new XML document tag needs processing. + * + * @author dtseng@google.com (David Tseng) + */ +public class AccessibilityValidationContentHandler extends DefaultHandler { + /** Used to obtain line information within the XML file. */ + private Locator mLocator; + /** The location of the file we are handling. */ + private final String mPath; + /** The total number of errors within the current file. */ + private int mValidationErrors = 0; + + /** + * Element tags we have seen before and determined not to be + * subclasses of ImageView. + */ + private final Set<String> mExclusionList = new HashSet<String>(); + + /** The path to the Android sdk jar file. */ + private final File mAndroidSdkPath; + + /** + * The ImageView class stored for easy comparison while handling content. It + * gets initialized in the {@link AccessibilityValidationHandler} + * constructor if not already done so. + */ + private static Class<?> sImageViewElement; + + /** + * A class loader properly initialized and reusable across files. It gets + * initialized in the {@link AccessibilityValidationHandler} constructor if + * not already done so. + */ + private static ClassLoader sValidationClassLoader; + + /** Attributes we test existence for (for example, contentDescription). */ + private static final HashSet<String> sExpectedAttributes = + new HashSet<String>(); + + /** The object that handles our logging. */ + private static final Logger sLogger = Logger.getLogger("android.accessibility"); + + /** + * Construct an AccessibilityValidationContentHandler object with the file + * on which validation occurs and a path to the Android sdk jar. Then, + * initialize the class members if not previously done so. + * + * @throws IllegalArgumentException + * when given an invalid Android sdk path or when unable to + * locate {@link ImageView} class. + */ + public AccessibilityValidationContentHandler(String fullyQualifiedPath, + File androidSdkPath) throws IllegalArgumentException { + mPath = fullyQualifiedPath; + mAndroidSdkPath = androidSdkPath; + + initializeAccessibilityValidationContentHandler(); + } + + /** + * Used to log line numbers of errors in {@link #startElement}. + */ + @Override + public void setDocumentLocator(Locator locator) { + mLocator = locator; + } + + /** + * For each subclass of ImageView, test for existence of the specified + * attributes. + */ + @Override + public void startElement(String uri, String localName, String qName, + Attributes atts) { + Class<?> potentialClass; + String classPath = "android.widget." + localName; + try { + potentialClass = sValidationClassLoader.loadClass(classPath); + } catch (ClassNotFoundException cnfException) { + return; // do nothing as the class doesn't exist. + } + + // if we already determined this class path isn't a subclass of + // ImageView, skip it. + // Otherwise, check to see if it is a subclass. + if (mExclusionList.contains(classPath)) { + return; + } else if (!sImageViewElement.isAssignableFrom(potentialClass)) { + mExclusionList.add(classPath); + return; + } + + boolean hasAttribute = false; + StringBuilder extendedOutput = new StringBuilder(); + for (int i = 0; i < atts.getLength(); i++) { + String currentAttribute = atts.getLocalName(i).toLowerCase(); + if (sExpectedAttributes.contains(currentAttribute)) { + hasAttribute = true; + break; + } else if (currentAttribute.equals("id")) { + extendedOutput.append("|id=" + currentAttribute); + } else if (currentAttribute.equals("src")) { + extendedOutput.append("|src=" + atts.getValue(i)); + } + } + + if (!hasAttribute) { + if (getValidationErrors() == 0) { + sLogger.info(mPath); + } + sLogger.info(String.format("ln: %s. Error in %s%s tag.", + mLocator.getLineNumber(), localName, extendedOutput)); + mValidationErrors++; + } + } + + /** + * Returns the total number of errors encountered in this file. + */ + public int getValidationErrors() { + return mValidationErrors; + } + + /** + * Set the class loader and ImageView class objects that will be used during + * the startElement validation logic. The class loader encompasses the class + * paths provided. + * + * @throws ClassNotFoundException + * when the ImageView Class object could not be found within the + * provided class loader. + */ + public static void setClassLoaderAndBaseClass(URL[] urlSearchPaths) + throws ClassNotFoundException { + sValidationClassLoader = new URLClassLoader(urlSearchPaths); + sImageViewElement = + sValidationClassLoader.loadClass("android.widget.ImageView"); + } + + /** + * Adds an attribute that will be tested for existence in + * {@link #startElement}. The search will always be case-insensitive. + */ + private static void addExpectedAttribute(String attribute) { + sExpectedAttributes.add(attribute.toLowerCase()); + } + + /** + * Initializes the class loader and {@link ImageView} Class objects. + * + * @throws IllegalArgumentException + * when either an invalid path is provided or ImageView cannot + * be found in the classpaths. + */ + private void initializeAccessibilityValidationContentHandler() + throws IllegalArgumentException { + if (sValidationClassLoader != null && sImageViewElement != null) { + return; // These objects are already initialized. + } + try { + setClassLoaderAndBaseClass(new URL[] { mAndroidSdkPath.toURL() }); + } catch (MalformedURLException mUException) { + throw new IllegalArgumentException("invalid android sdk path", + mUException); + } catch (ClassNotFoundException cnfException) { + throw new IllegalArgumentException( + "Unable to find ImageView class.", cnfException); + } + + // Add all of the expected attributes. + addExpectedAttribute("contentDescription"); + } +} diff --git a/AccessCheck/src/com/android/accessibility/AccessibilityValidator.java b/AccessCheck/src/com/android/accessibility/AccessibilityValidator.java new file mode 100644 index 0000000..5f3b031 --- /dev/null +++ b/AccessCheck/src/com/android/accessibility/AccessibilityValidator.java @@ -0,0 +1,191 @@ +/* + * Copyright 2010 Google Inc. + * + * 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.accessibility; + +import org.xml.sax.InputSource; +import org.xml.sax.SAXException; +import org.xml.sax.XMLReader; +import org.xml.sax.helpers.XMLReaderFactory; + +import java.io.*; +import java.util.ArrayList; +import java.util.List; +import java.util.logging.Logger; + +/** + * An object that fetches all Android layout files and manages the testing of + * the files with the use of the AccessibilityValidationContentHandler. This + * object also reports on any errors encountered during the testing. + * + * @author dtseng@google.com (David Tseng) + */ +public class AccessibilityValidator { + /** The root path to scan for Android layout files. */ + private final File mRootFilePath; + /** Errors generated by thrown exceptions (and not by validation errors). */ + private final List<String> mGeneralErrors = new ArrayList<String>(); + /** A list of files we wish to have tested. */ + private List<InputSource> mLayoutFiles; + /** The total number of validation test errors across all files. */ + private int mTotalValidationErrors = 0; + /** The path to the Android sdk jar. */ + private final File mAndroidSdkPath; + + /** The object that handles our logging. */ + private static final Logger sLogger = Logger.getLogger("android.accessibility"); + + /** + * The entry point to this tool. + * + * @param <args> + * path on which to search for layout xml files that need + * validation + */ + public static void main(String[] args) { + sLogger.info("AccessibilityValidator"); + if (args.length == 2) { + sLogger.info("Validating classes using android jar for subclasses of ImageView"); + new AccessibilityValidator(args[0], args[1]).run(); + } else { + sLogger.info("Usage: java AccessibilityValidator <path> <Android jar path>"); + return; + } + } + + /** + * Constructs an AccessibilityValidator object using the root path and the + * android jar path. + */ + public AccessibilityValidator(String rootPath, String androidSdkPath) { + mRootFilePath = new File(rootPath); + mAndroidSdkPath = new File(androidSdkPath); + + if (!mRootFilePath.exists()) { + throw new IllegalArgumentException("Invalid root path specified " + + rootPath); + } else if (!mAndroidSdkPath.exists()) { + throw new IllegalArgumentException( + "Invalid android sdk path specified " + androidSdkPath); + } + } + + /** + * Performs validation of Android layout files and logs errors that have + * been encountered during the validation. Returns true if the validation + * passes. + */ + private boolean run() { + sLogger.info("Validating files under " + mRootFilePath); + mLayoutFiles = findLayoutFiles(mRootFilePath); + validateFiles(); + for (String error : mGeneralErrors) { + sLogger.info(error); + } + sLogger.info("done with validation"); + return mGeneralErrors.size() == 0; + } + + /** + * Accumulates a list of files under the path that meet two constraints. + * Firstly, it has a containing (parent) directory of "layout". Secondly, it + * has an xml extension + */ + private List<InputSource> findLayoutFiles(File directory) { + List<InputSource> layoutFiles = new ArrayList<InputSource>(); + + for (File file : directory.listFiles()) { + // The file is a directory; recurse on the file. + if (file.isDirectory()) { + List<InputSource> directoryFiles = findLayoutFiles(file); + layoutFiles.addAll(directoryFiles); + // Does the containing directory and filename meet our + // constraints? + } else if (directory.getName().toLowerCase().contains("layout") + && file.getName().toLowerCase().endsWith(".xml")) { + InputSource addition; + try { + addition = new InputSource(new FileReader(file)); + // Store this explicitly for logging. + addition.setPublicId(file.toString()); + layoutFiles.add(addition); + } catch (FileNotFoundException fileNotFoundException) { + mGeneralErrors.add("File not found " + + fileNotFoundException); + } + } + } + + return layoutFiles; + } + + /* + * Processes a list of files via an AccessibilityValidationContentHandler. + * The caller will only be notified of errors via logging. + */ + public void validateFiles() { + sLogger.info("Validating " + getLayoutFiles().size()); + XMLReader reader; + try { + reader = XMLReaderFactory.createXMLReader(); + } catch (SAXException saxExp) { + mGeneralErrors.add("Error " + saxExp); + return; + } + for (InputSource file : getLayoutFiles()) { + try { + AccessibilityValidationContentHandler contentHandler + = new AccessibilityValidationContentHandler( + file.getPublicId(), mAndroidSdkPath); + reader.setContentHandler(contentHandler); + reader.parse(file); + mTotalValidationErrors += contentHandler.getValidationErrors(); + } catch (IOException ioExp) { + mGeneralErrors.add("Error reading file " + ioExp); + } catch (SAXException saxExp) { + mGeneralErrors.add("Error " + saxExp); + } + } + } + + /** + * Returns the number of general errors (considered caught exceptions). + */ + public List<String> getGeneralErrors() { + return mGeneralErrors; + } + + /** + * Sets the files to be tested. + */ + public void setLayoutFiles(List<InputSource> layoutFiles) { + this.mLayoutFiles = layoutFiles; + } + + /** + * Gets the files to be tested. + */ + public List<InputSource> getLayoutFiles() { + return mLayoutFiles; + } + + /** + * Gets the total number of test validation errors across all files. + */ + public int getTotalValidationErrors() { + return mTotalValidationErrors; + } +} diff --git a/Android.mk b/Android.mk new file mode 100644 index 0000000..802574c --- /dev/null +++ b/Android.mk @@ -0,0 +1,27 @@ +# Copyright (C) 2010 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. +# +# + +LOCAL_PATH := $(call my-dir) + +include $(CLEAR_VARS) + +LOCAL_SRC_FILES := $(call all-java-files-under, AccessCheck/src) + +#LOCAL_MODULE_TAGS := optional + +LOCAL_MODULE := accessibilityvalidator + +include $(BUILD_HOST_JAVA_LIBRARY) diff --git a/MODULE_LICENSE_APACHE2 b/MODULE_LICENSE_APACHE2 new file mode 100755 index 0000000..e69de29 --- /dev/null +++ b/MODULE_LICENSE_APACHE2 @@ -0,0 +1,190 @@ + + Copyright 2010 Google Inc. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + + 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. + + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + |