Java tutorial
/* * Copyright (C) 2015 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; import static com.android.SdkConstants.ATTR_NAME; import static com.android.SdkConstants.DOT_JAR; import static com.android.SdkConstants.FN_ANNOTATIONS_ZIP; import static com.android.SdkConstants.VALUE_FALSE; import static com.android.SdkConstants.VALUE_TRUE; import static com.android.tools.lint.checks.SupportAnnotationDetector.PERMISSION_ANNOTATION; import com.android.annotations.NonNull; import com.android.annotations.Nullable; import com.android.annotations.VisibleForTesting; import com.android.builder.model.AndroidLibrary; import com.android.builder.model.AndroidProject; import com.android.builder.model.Dependencies; import com.android.builder.model.Variant; import com.android.tools.lint.client.api.JavaParser.DefaultTypeDescriptor; import com.android.tools.lint.client.api.JavaParser.ResolvedAnnotation; import com.android.tools.lint.client.api.JavaParser.ResolvedAnnotation.Value; import com.android.tools.lint.client.api.JavaParser.ResolvedClass; import com.android.tools.lint.client.api.JavaParser.ResolvedField; import com.android.tools.lint.client.api.JavaParser.ResolvedMethod; import com.android.tools.lint.client.api.JavaParser.ResolvedPackage; import com.android.tools.lint.client.api.JavaParser.TypeDescriptor; import com.android.tools.lint.client.api.LintClient; import com.android.tools.lint.detector.api.LintUtils; import com.android.tools.lint.detector.api.Project; import com.android.utils.XmlUtils; import com.google.common.base.Charsets; import com.google.common.base.Splitter; import com.google.common.collect.ArrayListMultimap; import com.google.common.collect.Lists; import com.google.common.collect.Maps; import com.google.common.collect.Multimap; import com.google.common.collect.Sets; import com.google.common.io.ByteStreams; import com.google.common.io.Closeables; import com.google.common.io.Files; import org.w3c.dom.Document; import org.w3c.dom.Element; import org.w3c.dom.Node; import org.w3c.dom.NodeList; import java.io.File; import java.io.FileInputStream; import java.io.IOException; import java.lang.reflect.Modifier; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Set; import java.util.jar.JarInputStream; import java.util.regex.Matcher; import java.util.regex.Pattern; import java.util.zip.ZipEntry; /** * Handler for IntelliJ database files for external annotations. * It can be pointed to an annotations .jar file, which it then reads, * and can return {@link ResolvedAnnotation} instances when queried * for annotations on a {@link ResolvedClass} or a {@link ResolvedMethod}, * including its parameters. */ public class ExternalAnnotationRepository { public static final String SDK_ANNOTATIONS_PATH = "platform-tools/api/annotations.zip"; //$NON-NLS-1$ public static final String FN_ANNOTATIONS_XML = "annotations.xml"; //$NON-NLS-1$ private static final boolean DEBUG = false; private static ExternalAnnotationRepository sSingleton; private final List<AnnotationsDatabase> mDatabases; private ExternalAnnotationRepository(@NonNull List<AnnotationsDatabase> databases) { mDatabases = databases; } @NonNull public static synchronized ExternalAnnotationRepository get(@NonNull LintClient client) { if (sSingleton == null) { HashSet<AndroidLibrary> seen = Sets.newHashSet(); Collection<Project> projects = client.getKnownProjects(); List<File> files = Lists.newArrayListWithExpectedSize(2); for (Project project : projects) { if (project.isGradleProject()) { Variant variant = project.getCurrentVariant(); AndroidProject model = project.getGradleProjectModel(); if (model != null && variant != null) { Dependencies dependencies = variant.getMainArtifact().getDependencies(); for (AndroidLibrary library : dependencies.getLibraries()) { addLibraries(files, library, seen); } } } } File sdkAnnotations = client.findResource(SDK_ANNOTATIONS_PATH); if (sdkAnnotations == null) { // Until the SDK annotations are bundled in platform tools, provide // a fallback for Gradle builds to point to a locally installed version String path = System.getenv("SDK_ANNOTATIONS"); if (path != null) { sdkAnnotations = new File(path); if (!sdkAnnotations.exists()) { sdkAnnotations = null; } } } if (sdkAnnotations != null) { files.add(sdkAnnotations); } sSingleton = create(client, files); } return sSingleton; } @VisibleForTesting @NonNull static synchronized ExternalAnnotationRepository create(@Nullable LintClient client, @NonNull List<File> files) { long begin; if (DEBUG) { begin = System.currentTimeMillis(); } List<AnnotationsDatabase> databases = Lists.newArrayListWithExpectedSize(files.size()); for (File file : files) { try { AnnotationsDatabase database = getDatabase(file); if (database != null) { databases.add(database); } } catch (IOException ioe) { if (client != null) { client.log(ioe, "Could not read %1$s", file.getPath()); } else { ioe.printStackTrace(); } } } ExternalAnnotationRepository manager = new ExternalAnnotationRepository(databases); if (DEBUG) { long end = System.currentTimeMillis(); System.out.println("Initialization of annotations took " + (end - begin) + " ms"); } return manager; } private static void addLibraries(@NonNull List<File> result, @NonNull AndroidLibrary library, Set<AndroidLibrary> seen) { if (seen.contains(library)) { return; } seen.add(library); // As of 1.2 this is available in the model: // https://android-review.googlesource.com/#/c/137750/ // Switch over to this when it's in more common usage // (until it is, we'll pay for failed proxying errors) File zip = new File(library.getResFolder().getParent(), FN_ANNOTATIONS_ZIP); if (zip.exists()) { result.add(zip); } for (AndroidLibrary dependency : library.getLibraryDependencies()) { addLibraries(result, dependency, seen); } } @Nullable private static AnnotationsDatabase getDatabase(@NonNull LintClient client, @NonNull File file) { try { return file.isFile() ? new AnnotationsDatabase(file) : null; } catch (IOException ioe) { client.log(ioe, "Could not read %1$s", file.getPath()); return null; } } @VisibleForTesting @Nullable static AnnotationsDatabase getDatabase(@NonNull File file) throws IOException { return file.exists() ? new AnnotationsDatabase(file) : null; } @Nullable private static AnnotationsDatabase getDatabase(@NonNull LintClient client, @NonNull AndroidLibrary library) { // As of 1.2 this is available in the model: // https://android-review.googlesource.com/#/c/137750/ // Switch over to this when it's in more common usage // (until it is, we'll pay for failed proxying errors) File zip = new File(library.getResFolder().getParent(), FN_ANNOTATIONS_ZIP); return getDatabase(client, zip); } // ---- Query methods ---- @Nullable public ResolvedAnnotation getAnnotation(@NonNull ResolvedMethod method, @NonNull String type) { for (AnnotationsDatabase database : mDatabases) { ResolvedAnnotation annotation = database.getAnnotation(method, type); if (annotation != null) { return annotation; } } return null; } @Nullable public Collection<ResolvedAnnotation> getAnnotations(@NonNull ResolvedMethod method) { for (AnnotationsDatabase database : mDatabases) { Collection<ResolvedAnnotation> annotations = database.getAnnotations(method); if (annotations != null) { return annotations; } } return null; } @Nullable public ResolvedAnnotation getAnnotation(@NonNull ResolvedMethod method, int parameterIndex, @NonNull String type) { for (AnnotationsDatabase database : mDatabases) { ResolvedAnnotation annotation = database.getAnnotation(method, parameterIndex, type); if (annotation != null) { return annotation; } } return null; } @Nullable public Collection<ResolvedAnnotation> getAnnotations(@NonNull ResolvedMethod method, int parameterIndex) { for (AnnotationsDatabase database : mDatabases) { Collection<ResolvedAnnotation> annotations = database.getAnnotations(method, parameterIndex); if (annotations != null) { return annotations; } } return null; } @Nullable public ResolvedAnnotation getAnnotation(@NonNull ResolvedClass cls, @NonNull String type) { for (AnnotationsDatabase database : mDatabases) { ResolvedAnnotation annotation = database.getAnnotation(cls, type); if (annotation != null) { return annotation; } } return null; } @Nullable public Collection<ResolvedAnnotation> getAnnotations(@NonNull ResolvedClass cls) { for (AnnotationsDatabase database : mDatabases) { Collection<ResolvedAnnotation> annotations = database.getAnnotations(cls); if (annotations != null) { return annotations; } } return null; } @Nullable public ResolvedAnnotation getAnnotation(@NonNull ResolvedField field, @NonNull String type) { for (AnnotationsDatabase database : mDatabases) { ResolvedAnnotation annotation = database.getAnnotation(field, type); if (annotation != null) { return annotation; } } return null; } @Nullable public Collection<ResolvedAnnotation> getAnnotations(@NonNull ResolvedField field) { for (AnnotationsDatabase database : mDatabases) { Collection<ResolvedAnnotation> annotations = database.getAnnotations(field); if (annotations != null) { return annotations; } } return null; } @Nullable public Collection<ResolvedAnnotation> getAnnotations(@NonNull ResolvedAnnotation cls) { for (AnnotationsDatabase database : mDatabases) { Collection<ResolvedAnnotation> annotations = database.getAnnotations(cls); if (annotations != null) { return annotations; } } return null; } @Nullable public ResolvedAnnotation getAnnotation(@NonNull ResolvedPackage pkg, @NonNull String type) { for (AnnotationsDatabase database : mDatabases) { ResolvedAnnotation annotation = database.getAnnotation(pkg, type); if (annotation != null) { return annotation; } } return null; } @Nullable public Collection<ResolvedAnnotation> getAnnotations(@NonNull ResolvedPackage pkg) { for (AnnotationsDatabase database : mDatabases) { Collection<ResolvedAnnotation> annotations = database.getAnnotations(pkg); if (annotations != null) { return annotations; } } return null; } // ---- Reading from storage ---- private static final Pattern XML_SIGNATURE = Pattern.compile( // Class (FieldName | Type? Name(ArgList) Argnum?) "(\\S+) (\\S+|((.*)\\s+)?(\\S+)\\((.*)\\)( \\d+)?)"); /** Map from class fully qualified name to the class annotations info */ // Query database private static class ClassInfo { public List<ResolvedAnnotation> annotations; public Multimap<String, MethodInfo> methods; public Map<String, FieldInfo> fields; } private static class MethodInfo { public String parameters; public boolean constructor; public List<ResolvedAnnotation> annotations; public Multimap<Integer, ResolvedAnnotation> parameterAnnotations; } private static class FieldInfo { public List<ResolvedAnnotation> annotations; } /** An {@linkplain AnnotationsDatabase} corresponds to a single external annotations .zip * file (or if in the dev tree, a corresponding directory tree. * <p> * The SDK has an annotations database, and AAR libraries can also supply individual databases. * The {@linkplain ExternalAnnotationRepository} class manages all of these and performs lookup * into the various databases through a single entrypoint. * */ static class AnnotationsDatabase { AnnotationsDatabase(@NonNull File file) throws IOException { String path = file.getPath(); if (path.endsWith(DOT_JAR) || path.endsWith(FN_ANNOTATIONS_ZIP)) { initializeFromJar(file); } else { assert file.isDirectory() : file; initializeFromDirectory(file); } } // ---- Query methods ---- @Nullable public ResolvedAnnotation getAnnotation(@NonNull ResolvedMethod method, @NonNull String type) { MethodInfo m = findMethod(method); if (m == null) { return null; } if (m.annotations != null) { for (ResolvedAnnotation annotation : m.annotations) { if (type.equals(annotation.getSignature())) { return annotation; } } } return null; } @Nullable public List<ResolvedAnnotation> getAnnotations(@NonNull ResolvedMethod method) { MethodInfo m = findMethod(method); if (m == null) { return null; } return m.annotations; } @Nullable public ResolvedAnnotation getAnnotation(@NonNull ResolvedMethod method, int parameterIndex, @NonNull String type) { MethodInfo m = findMethod(method); if (m == null) { return null; } if (m.parameterAnnotations != null) { Collection<ResolvedAnnotation> annotations = m.parameterAnnotations.get(parameterIndex); if (annotations != null) { for (ResolvedAnnotation annotation : annotations) { if (type.equals(annotation.getSignature())) { return annotation; } } } } return null; } @Nullable public Collection<ResolvedAnnotation> getAnnotations(@NonNull ResolvedMethod method, int parameterIndex) { MethodInfo m = findMethod(method); if (m == null) { return null; } if (m.parameterAnnotations != null) { return m.parameterAnnotations.get(parameterIndex); } return m.annotations; } @Nullable public ResolvedAnnotation getAnnotation(@NonNull ResolvedClass cls, @NonNull String type) { ClassInfo c = findClass(cls); if (c == null) { return null; } if (c.annotations != null) { for (ResolvedAnnotation annotation : c.annotations) { if (type.equals(annotation.getSignature())) { return annotation; } } } return null; } @Nullable public List<ResolvedAnnotation> getAnnotations(@NonNull ResolvedClass cls) { ClassInfo c = findClass(cls); if (c == null) { return null; } return c.annotations; } @Nullable public List<ResolvedAnnotation> getAnnotations(@NonNull ResolvedAnnotation cls) { ClassInfo c = findClass(cls); if (c == null) { return null; } return c.annotations; } @Nullable public ResolvedAnnotation getAnnotation(@NonNull ResolvedPackage pkg, @NonNull String type) { ClassInfo c = findPackage(pkg); if (c == null) { return null; } if (c.annotations != null) { for (ResolvedAnnotation annotation : c.annotations) { if (type.equals(annotation.getSignature())) { return annotation; } } } return null; } @Nullable public List<ResolvedAnnotation> getAnnotations(@NonNull ResolvedPackage pkg) { ClassInfo c = findPackage(pkg); if (c == null) { return null; } return c.annotations; } @Nullable public ResolvedAnnotation getAnnotation(@NonNull ResolvedField field, @NonNull String type) { FieldInfo f = findField(field); if (f == null) { return null; } if (f.annotations != null) { for (ResolvedAnnotation annotation : f.annotations) { if (type.equals(annotation.getSignature())) { return annotation; } } } return null; } @Nullable public List<ResolvedAnnotation> getAnnotations(@NonNull ResolvedField field) { FieldInfo f = findField(field); if (f == null) { return null; } return f.annotations; } // ---- Initialization ---- private void initializeFromDirectory(File file) throws IOException { if (file.isDirectory()) { File[] files = file.listFiles(); if (files != null) { for (File f : files) { initializeFromDirectory(f); } } } else if (file.getPath().endsWith(FN_ANNOTATIONS_XML)) { String xml = Files.toString(file, Charsets.UTF_8); initializePackage(xml, file.getPath()); } } private void initializeFromJar(File file) throws IOException { // Reads in an existing annotations jar and merges in entries found there // with the annotations analyzed from source. JarInputStream zis = null; try { @SuppressWarnings("IOResourceOpenedButNotSafelyClosed") FileInputStream fis = new FileInputStream(file); zis = new JarInputStream(fis); ZipEntry entry = zis.getNextEntry(); while (entry != null) { if (entry.getName().endsWith(".xml")) { byte[] bytes = ByteStreams.toByteArray(zis); String xml = new String(bytes, Charsets.UTF_8); initializePackage(xml, entry.getName()); } entry = zis.getNextEntry(); } } finally { try { Closeables.close(zis, true); } catch (IOException e) { // pass } } } /** * Takes the XML contents of an annotations.xml file, parses it and initialize * the necessary data structures */ private void initializePackage(@NonNull String xml, @NonNull String path) throws IOException { try { Document document = XmlUtils.parseDocument(xml, false); Element root = document.getDocumentElement(); String rootTag = root.getTagName(); assert rootTag.equals("root") : rootTag; for (Element item : LintUtils.getChildren(root)) { String signature = item.getAttribute(ATTR_NAME); if (signature == null || signature.equals("null")) { continue; // malformed item } signature = XmlUtils.fromXmlAttributeValue(signature); Matcher matcher = XML_SIGNATURE.matcher(signature); if (matcher.matches()) { String containingClass = matcher.group(1); if (containingClass == null) { throw new IOException("Could not find class for " + signature); } String methodName = matcher.group(5); if (methodName != null) { String type = matcher.group(4); boolean isConstructor = type == null; String parameters = matcher.group(6); mergeMethodOrParameter(item, matcher, containingClass, methodName, isConstructor, parameters); } else { String fieldName = matcher.group(2); mergeField(item, containingClass, fieldName); } } else if (signature.indexOf(' ') == -1 && signature.indexOf('.') != -1) { mergeClass(item, signature); } else { throw new IOException("No merge match for signature " + signature); } } } catch (Exception e) { throw new IOException("Could not parse XML from " + path); } } // SDK annotations private Map<String, ClassInfo> mClassMap = Maps.newHashMapWithExpectedSize(800); @Nullable private ClassInfo findClass(@NonNull ResolvedClass cls) { return mClassMap.get(cls.getName()); } @Nullable private ClassInfo findClass(@NonNull ResolvedAnnotation cls) { return mClassMap.get(cls.getName()); } private ClassInfo findPackage(@NonNull ResolvedPackage pkg) { return mClassMap.get(pkg.getName() + ".package-info"); } @Nullable private MethodInfo findMethod(@NonNull ResolvedMethod method) { ClassInfo c = findClass(method.getContainingClass()); if (c == null) { return null; } if (c.methods == null) { return null; } Collection<MethodInfo> methods = c.methods.get(method.getName()); if (methods == null) { return null; } boolean constructor = method.isConstructor(); for (MethodInfo m : methods) { if (constructor != m.constructor) { continue; } // Check parameter types // TODO: Perform faster parameter check! This is inefficient // Stash parameter count such that I can quickly compare the two String signature = m.parameters; int index = 0; boolean matches = true; for (int i = 0, n = method.getArgumentCount(); i < n; i++) { String parameterType = method.getArgumentType(i).getSignature(); int length = parameterType.indexOf('<'); if (length == -1) { length = parameterType.length(); } if (!signature.regionMatches(false, index, parameterType, 0, length)) { // Check if we have a varargs match: x... vs x[] if (length <= 3 || index <= 3 || ((parameterType.charAt(length - 1) != '.') && (signature.length() < index + length || signature.charAt(index + length - 1) != '.')) || !isVarArgsMatch(signature, index, parameterType, length)) { matches = false; break; } } index += length; if (i < n - 1) { if (index == signature.length()) { matches = false; break; } else if (signature.charAt(index) == '<') { // Skip raw types int balance = 1; for (int j = index + 1, max = signature.length(); j < max; j++) { char ch = signature.charAt(j); if (ch == '<') { balance++; } else if (ch == '>') { balance--; if (balance == 0) { index = j + 1; break; } } } if (balance > 0) { matches = false; break; } } else if (signature.charAt(index) != ',') { matches = false; break; } } index++; // skip comma } if (matches) { return m; } } return null; } /** * Checks whether the string at parameterType(0,length) and signature(index,index+length) * are the same, except with one possibly ending with [] and the other with ... - if * so these should be taken to match */ private static boolean isVarArgsMatch(String signature, int index, String parameterType, int length) { return parameterType.regionMatches(false, length - 3, "...", 0, 3) && signature.regionMatches(false, index + length - 3, "[]", 0, 2) && parameterType.regionMatches(false, 0, signature, index, length - 3) || parameterType.regionMatches(false, length - 2, "[]", 0, 2) && signature.regionMatches(false, index + length - 2, "...", 0, 3) && parameterType.regionMatches(false, 0, signature, index, length - 2); } @Nullable private FieldInfo findField(@NonNull ResolvedField field) { ClassInfo c = findClass(field.getContainingClass()); if (c == null) { return null; } if (c.fields == null) { return null; } return c.fields.get(field.getName()); } @NonNull private MethodInfo createMethod(@NonNull String containingClass, @NonNull String methodName, boolean constructor, @NonNull String parameters) { ClassInfo cls = createClass(containingClass); if (cls.methods != null) { Collection<MethodInfo> methods = cls.methods.get(methodName); if (methods != null) { for (MethodInfo method : methods) { if (parameters.equals(method.parameters) && constructor == method.constructor) { return method; } } } } MethodInfo method = new MethodInfo(); method.parameters = parameters; method.constructor = constructor; if (cls.methods == null) { cls.methods = ArrayListMultimap.create(); // TODO: Size me } cls.methods.put(methodName, method); return method; } @NonNull private ClassInfo createClass(@NonNull String containingClass) { ClassInfo cls = mClassMap.get(containingClass); if (cls == null) { cls = new ClassInfo(); mClassMap.put(containingClass, cls); } return cls; } @NonNull private FieldInfo createField(@NonNull String containingClass, @NonNull String fieldName) { ClassInfo cls = createClass(containingClass); if (cls.fields != null) { FieldInfo field = cls.fields.get(fieldName); if (field != null) { return field; } } FieldInfo field = new FieldInfo(); if (cls.fields == null) { cls.fields = Maps.newHashMap(); // TODO: Size me } cls.fields.put(fieldName, field); return field; } private void mergeMethodOrParameter(Element item, Matcher matcher, String containingClass, String methodName, boolean constructor, String parameters) { parameters = fixParameterString(parameters); MethodInfo method = createMethod(containingClass, methodName, constructor, parameters); List<ResolvedAnnotation> annotations = createAnnotations(item); String argNum = matcher.group(7); if (argNum != null) { argNum = argNum.trim(); int parameter = Integer.parseInt(argNum); if (method.parameterAnnotations == null) { // Do I know the parameter count here? int parameterCount = 4; method.parameterAnnotations = ArrayListMultimap.create(parameterCount, annotations.size()); } for (ResolvedAnnotation annotation : annotations) { method.parameterAnnotations.put(parameter, annotation); } } else { if (method.annotations == null) { method.annotations = Lists.newArrayListWithExpectedSize(annotations.size()); } method.annotations.addAll(annotations); } } private void mergeField(Element item, String containingClass, String fieldName) { FieldInfo field = createField(containingClass, fieldName); List<ResolvedAnnotation> annotations = createAnnotations(item); if (field.annotations == null) { field.annotations = Lists.newArrayListWithExpectedSize(annotations.size()); } field.annotations.addAll(annotations); } private void mergeClass(Element item, String containingClass) { ClassInfo cls = createClass(containingClass); List<ResolvedAnnotation> annotations = createAnnotations(item); if (cls.annotations == null) { cls.annotations = Lists.newArrayListWithExpectedSize(annotations.size()); } cls.annotations.addAll(annotations); } private List<ResolvedAnnotation> createAnnotations(Element itemElement) { List<Element> children = getChildren(itemElement); List<ResolvedAnnotation> result = Lists.newArrayListWithExpectedSize(children.size()); for (Element annotationElement : children) { ResolvedAnnotation annotation = createAnnotation(annotationElement); result.add(annotation); } return result; } private static class ResolvedExternalAnnotation extends ResolvedAnnotation { @NonNull private String mSignature; @Nullable private List<Value> mValues; public ResolvedExternalAnnotation(@NonNull String signature) { mSignature = signature; } void addValue(@NonNull Value value) { if (mValues == null) { mValues = Lists.newArrayList(); } mValues.add(value); } @NonNull @Override public String getName() { return mSignature; } @NonNull @Override public String getSignature() { return mSignature; } @Override public int getModifiers() { return Modifier.PUBLIC; } @NonNull @Override public Iterable<ResolvedAnnotation> getAnnotations() { return Collections.emptyList(); } @Override public boolean matches(@NonNull String name) { return mSignature.equals(name); } @NonNull @Override public TypeDescriptor getType() { return new DefaultTypeDescriptor(mSignature); } @Nullable @Override public ResolvedClass getClassType() { // No nested annotations in the database return null; } @NonNull @Override public List<Value> getValues() { return mValues == null ? Collections.<Value>emptyList() : mValues; } } private Map<String, ResolvedExternalAnnotation> mMarkerAnnotations = Maps.newHashMapWithExpectedSize(30); private ResolvedAnnotation createAnnotation(Element annotationElement) { String tagName = annotationElement.getTagName(); assert tagName.equals("annotation") : tagName; String name = annotationElement.getAttribute(ATTR_NAME); assert name != null && !name.isEmpty(); ResolvedExternalAnnotation annotation = mMarkerAnnotations.get(name); if (annotation != null) { return annotation; } annotation = new ResolvedExternalAnnotation(name); List<Element> valueElements = getChildren(annotationElement); if (valueElements.isEmpty() // Permission annotations are sometimes used as marker annotations (on // parameters) but that shouldn't let us conclude that any future // permission annotations are && !name.startsWith(PERMISSION_ANNOTATION)) { mMarkerAnnotations.put(name, annotation); return annotation; } for (Element valueElement : valueElements) { if (valueElement.getTagName().equals("val")) { String valueName = valueElement.getAttribute(ATTR_NAME); String valueString = valueElement.getAttribute("val"); if (!valueName.isEmpty() && !valueString.isEmpty()) { // Guess type Object value; if (valueString.equals(VALUE_TRUE)) { value = true; } else if (valueString.equals(VALUE_FALSE)) { value = false; } else if (valueString.startsWith("\"") && valueString.endsWith("\"") && valueString.length() >= 2) { value = valueString.substring(1, valueString.length() - 1); } else if (valueString.startsWith("{") && valueString.endsWith("}")) { // Array of values String listString = valueString.substring(1, valueString.length() - 1); // We don't know the types, but we'll assume that they're either // all strings (the most common array type in our annotations), or // field references. We can't know the types of the fields; it's // not part of the annotation metadata. We'll place them in an Object[] // for now. boolean allStrings = true; Splitter splitter = Splitter.on(',').omitEmptyStrings().trimResults(); List<Object> result = Lists.newArrayList(); for (String reference : splitter.split(listString)) { if (reference.startsWith("\"")) { result.add(reference.substring(1, reference.length() - 1)); } else { result.add(new ResolvedExternalField(reference)); allStrings = false; } } if (allStrings) { value = result.toArray(new String[result.size()]); } else { value = result.toArray(); } // We don't know the actual type of these fields; we'll assume they're // a special form of } else if (Character.isDigit(valueString.charAt(0))) { try { if (valueString.contains(".")) { value = Double.parseDouble(valueString); } else { value = Long.parseLong(valueString); } } catch (NumberFormatException nufe) { value = valueString; } } else { value = valueString; // unknown type } annotation.addValue(new Value(valueName, value)); } } } return annotation; } } /** Special implementation of a {@link ResolvedField} which can * do equality comparisons with {@link EcjParser.EcjResolvedField} */ private static class ResolvedExternalField extends ResolvedField { private final String mSignature; public ResolvedExternalField(String signature) { mSignature = signature; assert mSignature.indexOf(' ') == -1 : '"' + mSignature + '"'; } @NonNull @Override public String getName() { return mSignature.substring(mSignature.lastIndexOf('.') + 1); } @Override public String getSignature() { return mSignature; } @Override public boolean equals(Object obj) { if (obj instanceof ResolvedExternalField) { return mSignature.equals(((ResolvedExternalField) obj).mSignature); } else if (obj instanceof ResolvedField) { ResolvedField field = (ResolvedField) obj; if (mSignature.endsWith(field.getName())) { String signature = field.getContainingClass().getSignature() + "." + field.getName(); return mSignature.equals(signature); } return false; } else { return false; } } @Override public int hashCode() { return mSignature.hashCode(); } @Override public int getModifiers() { return 0; } @Override public boolean matches(@NonNull String name) { return mSignature.equals(name); } @NonNull @Override public TypeDescriptor getType() { return new DefaultTypeDescriptor(mSignature); } @NonNull @Override public ResolvedClass getContainingClass() { throw new UnsupportedOperationException(); } @Override public String getContainingClassName() { return mSignature.substring(0, mSignature.lastIndexOf('.')); } @Nullable @Override public Object getValue() { return null; } @NonNull @Override public Iterable<ResolvedAnnotation> getAnnotations() { return Collections.emptyList(); } } @NonNull private static List<Element> getChildren(@NonNull Element element) { NodeList itemList = element.getChildNodes(); int length = itemList.getLength(); if (length == 0) { return Collections.emptyList(); } List<Element> result = new ArrayList<Element>(Math.max(5, length / 2 + 1)); for (int i = 0; i < length; i++) { Node node = itemList.item(i); if (node.getNodeType() != Node.ELEMENT_NODE) { continue; } result.add((Element) node); } return result; } // The parameter declaration used in XML files should not have duplicated spaces, // and there should be no space after commas (we can't however strip out all spaces, // since for example the spaces around the "extends" keyword needs to be there in // types like Map<String,? extends Number> private static String fixParameterString(String parameters) { return parameters.replace(" ", " ").replace(", ", ","); } /** For test usage only */ @VisibleForTesting static synchronized void set(ExternalAnnotationRepository singleton) { assert singleton == null || sSingleton == null; sSingleton = singleton; } }