Java tutorial
/* * 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_PKG; import static com.android.SdkConstants.DOT_XML; import com.android.annotations.NonNull; import com.android.annotations.Nullable; import com.android.annotations.VisibleForTesting; import com.android.sdklib.repository.FullRevision; import com.android.sdklib.repository.descriptors.PkgType; import com.android.sdklib.repository.local.LocalPkgInfo; import com.android.sdklib.repository.local.LocalSdk; import com.android.tools.lint.client.api.LintClient; import com.android.tools.lint.detector.api.LintUtils; import com.google.common.base.Charsets; import com.google.common.collect.Lists; import com.google.common.collect.Maps; import com.google.common.collect.Sets; import com.google.common.io.Files; import com.google.common.primitives.UnsignedBytes; import java.io.File; import java.io.FileOutputStream; import java.io.IOException; import java.lang.ref.WeakReference; import java.nio.ByteBuffer; import java.nio.ByteOrder; import java.nio.MappedByteBuffer; import java.nio.channels.FileChannel.MapMode; import java.util.ArrayList; import java.util.Collections; import java.util.List; import java.util.Map; import java.util.Set; /** * Database for API checking: Allows quick lookup of a given class, method or field * to see which API level it was introduced in. * <p> * This class is optimized for quick bytecode lookup used in conjunction with the * ASM library: It has lookup methods that take internal JVM signatures, and for a method * call for example it processes the owner, name and description parameters separately * the way they are provided from ASM. * <p> * The {@link Api} class provides access to the full Android API along with version * information, initialized from an XML file. This lookup class adds a binary cache around * the API to make initialization faster and to require fewer objects. It creates * a binary cache data structure, which fits in a single byte array, which means that * to open the database you can just read in the byte array and go. On one particular * machine, this takes about 30-50 ms versus 600-800ms for the full parse. It also * helps memory by placing everything in a compact byte array instead of needing separate * strings (2 bytes per character in a char[] for the 25k method entries, 11k field entries * and 6k class entries) - and it also avoids the same number of Map.Entry objects. * When creating the memory data structure it performs a few other steps to help memory: * <ul> * <li> It stores the strings as single bytes, since all the JVM signatures are in ASCII * <li> It strips out the method return types (which takes the binary size down from * about 4.7M to 4.0M) * <li> It strips out all APIs that have since=1, since the lookup only needs to find * classes, methods and fields that have an API level *higher* than 1. This drops * the memory use down from 4.0M to 1.7M. * </ul> */ public class ApiLookup { /** Relative path to the api-versions.xml database file within the Lint installation */ private static final String XML_FILE_PATH = "platform-tools/api/api-versions.xml"; //$NON-NLS-1$ private static final String FILE_HEADER = "API database used by Android lint\000"; private static final int BINARY_FORMAT_VERSION = 6; private static final boolean DEBUG_FORCE_REGENERATE_BINARY = false; private static final boolean DEBUG_SEARCH = false; private static final boolean WRITE_STATS = false; /** Default size to reserve for each API entry when creating byte buffer to build up data */ private static final int BYTES_PER_ENTRY = 36; private final Api mInfo; private byte[] mData; private int[] mIndices; private int mClassCount; private String[] mJavaPackages; private static WeakReference<ApiLookup> sInstance = new WeakReference<ApiLookup>(null); /** * Returns an instance of the API database * * @param client the client to associate with this database - used only for * logging. The database object may be shared among repeated invocations, * and in that case client used will be the one originally passed in. * In other words, this parameter may be ignored if the client created * is not new. * @return a (possibly shared) instance of the API database, or null * if its data can't be found */ @Nullable public static ApiLookup get(@NonNull LintClient client) { synchronized (ApiLookup.class) { ApiLookup db = sInstance.get(); if (db == null) { File file = client.findResource(XML_FILE_PATH); if (file == null) { // AOSP build environment? String build = System.getenv("ANDROID_BUILD_TOP"); //$NON-NLS-1$ if (build != null) { file = new File(build, "development/sdk/api-versions.xml" //$NON-NLS-1$ .replace('/', File.separatorChar)); } } if (file == null || !file.exists()) { return null; } else { db = get(client, file); } sInstance = new WeakReference<ApiLookup>(db); } return db; } } @VisibleForTesting @Nullable static String getPlatformVersion(@NonNull LintClient client) { LocalSdk sdk = client.getSdk(); if (sdk != null) { LocalPkgInfo pkgInfo = sdk.getPkgInfo(PkgType.PKG_PLATFORM_TOOLS); if (pkgInfo != null) { FullRevision version = pkgInfo.getDesc().getFullRevision(); if (version != null) { return version.toShortString(); } } } return null; } @VisibleForTesting @NonNull static String getCacheFileName(@NonNull String xmlFileName, @Nullable String platformVersion) { if (LintUtils.endsWith(xmlFileName, DOT_XML)) { xmlFileName = xmlFileName.substring(0, xmlFileName.length() - DOT_XML.length()); } StringBuilder sb = new StringBuilder(100); sb.append(xmlFileName); // Incorporate version number in the filename to avoid upgrade filename // conflicts on Windows (such as issue #26663) sb.append('-').append(BINARY_FORMAT_VERSION); if (platformVersion != null) { sb.append('-').append(platformVersion); } sb.append(".bin"); //$NON-NLS-1$ return sb.toString(); } /** * Returns an instance of the API database * * @param client the client to associate with this database - used only for * logging * @param xmlFile the XML file containing configuration data to use for this * database * @return a (possibly shared) instance of the API database, or null * if its data can't be found */ private static ApiLookup get(LintClient client, File xmlFile) { if (!xmlFile.exists()) { client.log(null, "The API database file %1$s does not exist", xmlFile); return null; } File cacheDir = client.getCacheDir(true/*create*/); if (cacheDir == null) { cacheDir = xmlFile.getParentFile(); } String platformVersion = getPlatformVersion(client); File binaryData = new File(cacheDir, getCacheFileName(xmlFile.getName(), platformVersion)); if (DEBUG_FORCE_REGENERATE_BINARY) { System.err.println("\nTemporarily regenerating binary data unconditionally \nfrom " + xmlFile + "\nto " + binaryData); if (!createCache(client, xmlFile, binaryData)) { return null; } } else if (!binaryData.exists() || binaryData.lastModified() < xmlFile.lastModified() || binaryData.length() == 0) { if (!createCache(client, xmlFile, binaryData)) { return null; } } if (!binaryData.exists()) { client.log(null, "The API database file %1$s does not exist", binaryData); return null; } return new ApiLookup(client, xmlFile, binaryData, null); } private static boolean createCache(LintClient client, File xmlFile, File binaryData) { long begin = 0; if (WRITE_STATS) { begin = System.currentTimeMillis(); } Api info = Api.parseApi(xmlFile); if (WRITE_STATS) { long end = System.currentTimeMillis(); System.out.println("Reading XML data structures took " + (end - begin) + " ms)"); } if (info != null) { try { writeDatabase(binaryData, info); return true; } catch (IOException ioe) { client.log(ioe, "Can't write API cache file"); } } return false; } /** Use one of the {@link #get} factory methods instead */ private ApiLookup(@NonNull LintClient client, @NonNull File xmlFile, @Nullable File binaryFile, @Nullable Api info) { mInfo = info; if (binaryFile != null) { readData(client, xmlFile, binaryFile); } } /** * Database format: * <pre> * 1. A file header, which is the exact contents of {@link #FILE_HEADER} encoded * as ASCII characters. The purpose of the header is to identify what the file * is for, for anyone attempting to open the file. * 2. A file version number. If the binary file does not match the reader's expected * version, it can ignore it (and regenerate the cache from XML). * 3. The number of classes [1 int] * 4. The number of members (across all classes) [1 int]. * 5. The number of java/javax packages [1 int] * 6. The java/javax package name table. Each item consists of a byte count for * the package string (as 1 byte) followed by the UTF-8 encoded bytes for each package. * These are in sorted order. * 7. Class offset table (one integer per class, pointing to the byte offset in the * file (relative to the beginning of the file) where each class begins. * The classes are always sorted alphabetically by fully qualified name. * 8. Member offset table (one integer per member, pointing to the byte offset in the * file (relative to the beginning of the file) where each member entry begins. * The members are always sorted alphabetically. * 9. Class entry table. Each class entry consists of the fully qualified class name, * in JVM format (using / instead of . in package names and $ for inner classes), * followed by the byte 0 as a terminator, followed by the API version as a byte. * 10. Member entry table. Each member entry consists of the class number (as a short), * followed by the JVM method/field signature, encoded as UTF-8, followed by a 0 byte * signature terminator, followed by the API level as a byte. * <p> * TODO: Pack the offsets: They increase by a small amount for each entry, so no need * to spend 4 bytes on each. These will need to be processed when read back in anyway, * so consider storing the offset -deltas- as single bytes and adding them up cumulatively * in readData(). * </pre> */ private void readData(@NonNull LintClient client, @NonNull File xmlFile, @NonNull File binaryFile) { if (!binaryFile.exists()) { client.log(null, "%1$s does not exist", binaryFile); return; } long start = System.currentTimeMillis(); try { MappedByteBuffer buffer = Files.map(binaryFile, MapMode.READ_ONLY); assert buffer.order() == ByteOrder.BIG_ENDIAN; // First skip the header byte[] expectedHeader = FILE_HEADER.getBytes(Charsets.US_ASCII); buffer.rewind(); for (int offset = 0; offset < expectedHeader.length; offset++) { if (expectedHeader[offset] != buffer.get()) { client.log(null, "Incorrect file header: not an API database cache " + "file, or a corrupt cache file"); return; } } // Read in the format number if (buffer.get() != BINARY_FORMAT_VERSION) { // Force regeneration of new binary data with up to date format if (createCache(client, xmlFile, binaryFile)) { readData(client, xmlFile, binaryFile); // Recurse } return; } mClassCount = buffer.getInt(); int methodCount = buffer.getInt(); int javaPackageCount = buffer.getInt(); // Read in the Java packages mJavaPackages = new String[javaPackageCount]; for (int i = 0; i < javaPackageCount; i++) { int count = UnsignedBytes.toInt(buffer.get()); byte[] bytes = new byte[count]; buffer.get(bytes, 0, count); mJavaPackages[i] = new String(bytes, Charsets.UTF_8); } // Read in the class table indices; int count = mClassCount + methodCount; int[] offsets = new int[count]; // Another idea: I can just store the DELTAS in the file (and add them up // when reading back in) such that it takes just ONE byte instead of four! for (int i = 0; i < count; i++) { offsets[i] = buffer.getInt(); } // No need to read in the rest -- we'll just keep the whole byte array in memory // TODO: Make this code smarter/more efficient. int size = buffer.limit(); byte[] b = new byte[size]; buffer.rewind(); buffer.get(b); mData = b; mIndices = offsets; // TODO: We only need to keep the data portion here since we've initialized // the offset array separately. // TODO: Investigate (profile) accessing the byte buffer directly instead of // accessing a byte array. } catch (Throwable e) { client.log(null, "Failure reading binary cache file %1$s", binaryFile.getPath()); client.log(null, "Please delete the file and restart the IDE/lint: %1$s", binaryFile.getPath()); client.log(e, null); } if (WRITE_STATS) { long end = System.currentTimeMillis(); System.out.println("\nRead API database in " + (end - start) + " milliseconds."); System.out.println("Size of data table: " + mData.length + " bytes (" + Integer.toString(mData.length / 1024) + "k)\n"); } } /** See the {@link #readData(LintClient,File,File)} for documentation on the data format. */ private static void writeDatabase(File file, Api info) throws IOException { /* * 1. A file header, which is the exact contents of {@link FILE_HEADER} encoded * as ASCII characters. The purpose of the header is to identify what the file * is for, for anyone attempting to open the file. * 2. A file version number. If the binary file does not match the reader's expected * version, it can ignore it (and regenerate the cache from XML). */ Map<String, ApiClass> classMap = info.getClasses(); // Write the class table List<String> classes = new ArrayList<String>(classMap.size()); Map<ApiClass, List<String>> memberMap = Maps.newHashMapWithExpectedSize(classMap.size()); int memberCount = 0; Set<String> javaPackageSet = Sets.newHashSetWithExpectedSize(70); for (Map.Entry<String, ApiClass> entry : classMap.entrySet()) { String className = entry.getKey(); ApiClass apiClass = entry.getValue(); if (className.startsWith("java/") //$NON-NLS-1$ || className.startsWith("javax/")) { //$NON-NLS-1$ String pkg = apiClass.getPackage(); javaPackageSet.add(pkg); } if (!isRelevantOwner(className)) { System.out.println("Warning: The isRelevantOwner method does not pass " + className); } Set<String> allMethods = apiClass.getAllMethods(info); Set<String> allFields = apiClass.getAllFields(info); // Strip out all members that have been supported since version 1. // This makes the database *much* leaner (down from about 4M to about // 1.7M), and this just fills the table with entries that ultimately // don't help the API checker since it just needs to know if something // requires a version *higher* than the minimum. If in the future the // database needs to answer queries about whether a method is public // or not, then we'd need to put this data back in. List<String> members = new ArrayList<String>(allMethods.size() + allFields.size()); for (String member : allMethods) { Integer since = apiClass.getMethod(member, info); if (since == null) { assert false : className + ':' + member; since = 1; } if (since != 1) { members.add(member); } } // Strip out all members that have been supported since version 1. // This makes the database *much* leaner (down from about 4M to about // 1.7M), and this just fills the table with entries that ultimately // don't help the API checker since it just needs to know if something // requires a version *higher* than the minimum. If in the future the // database needs to answer queries about whether a method is public // or not, then we'd need to put this data back in. for (String member : allFields) { Integer since = apiClass.getField(member, info); if (since == null) { assert false : className + ':' + member; since = 1; } if (since != 1) { members.add(member); } } // Only include classes that have one or more members requiring version 2 or higher: if (!members.isEmpty()) { classes.add(className); memberMap.put(apiClass, members); memberCount += members.size(); } } Collections.sort(classes); List<String> javaPackages = Lists.newArrayList(javaPackageSet); Collections.sort(javaPackages); int javaPackageCount = javaPackages.size(); int entryCount = classMap.size() + memberCount; int capacity = entryCount * BYTES_PER_ENTRY; ByteBuffer buffer = ByteBuffer.allocate(capacity); buffer.order(ByteOrder.BIG_ENDIAN); // 1. A file header, which is the exact contents of {@link FILE_HEADER} encoded // as ASCII characters. The purpose of the header is to identify what the file // is for, for anyone attempting to open the file. buffer.put(FILE_HEADER.getBytes(Charsets.US_ASCII)); // 2. A file version number. If the binary file does not match the reader's expected // version, it can ignore it (and regenerate the cache from XML). buffer.put((byte) BINARY_FORMAT_VERSION); // 3. The number of classes [1 int] buffer.putInt(classes.size()); // 4. The number of members (across all classes) [1 int]. buffer.putInt(memberCount); // 5. The number of Java packages [1 int]. buffer.putInt(javaPackageCount); // 6. The Java package table. There are javaPackage.size() entries, where each entry // consists of a string length, as a byte, followed by the bytes in the package. // There is no terminating 0. for (String pkg : javaPackages) { byte[] bytes = pkg.getBytes(Charsets.UTF_8); assert bytes.length < 255 : pkg; buffer.put((byte) bytes.length); buffer.put(bytes); } // 7. Class offset table (one integer per class, pointing to the byte offset in the // file (relative to the beginning of the file) where each class begins. // The classes are always sorted alphabetically by fully qualified name. int classOffsetTable = buffer.position(); // Reserve enough room for the offset table here: we will backfill it with pointers // as we're writing out the data structures below for (int i = 0, n = classes.size(); i < n; i++) { buffer.putInt(0); } // 8. Member offset table (one integer per member, pointing to the byte offset in the // file (relative to the beginning of the file) where each member entry begins. // The members are always sorted alphabetically. int methodOffsetTable = buffer.position(); for (int i = 0, n = memberCount; i < n; i++) { buffer.putInt(0); } int nextEntry = buffer.position(); int nextOffset = classOffsetTable; // 9. Class entry table. Each class entry consists of the fully qualified class name, // in JVM format (using / instead of . in package names and $ for inner classes), // followed by the byte 0 as a terminator, followed by the API version as a byte. for (String clz : classes) { buffer.position(nextOffset); buffer.putInt(nextEntry); nextOffset = buffer.position(); buffer.position(nextEntry); buffer.put(clz.getBytes(Charsets.UTF_8)); buffer.put((byte) 0); ApiClass apiClass = classMap.get(clz); assert apiClass != null : clz; int since = apiClass.getSince(); assert since == UnsignedBytes.toInt((byte) since) : since; // make sure it fits buffer.put((byte) since); nextEntry = buffer.position(); } // 10. Member entry table. Each member entry consists of the class number (as a short), // followed by the JVM method/field signature, encoded as UTF-8, followed by a 0 byte // signature terminator, followed by the API level as a byte. assert nextOffset == methodOffsetTable; for (int classNumber = 0, n = classes.size(); classNumber < n; classNumber++) { String clz = classes.get(classNumber); ApiClass apiClass = classMap.get(clz); assert apiClass != null : clz; List<String> members = memberMap.get(apiClass); Collections.sort(members); for (String member : members) { buffer.position(nextOffset); buffer.putInt(nextEntry); nextOffset = buffer.position(); buffer.position(nextEntry); Integer since; if (member.indexOf('(') != -1) { since = apiClass.getMethod(member, info); } else { since = apiClass.getField(member, info); } if (since == null) { assert false : clz + ':' + member; since = 1; } assert classNumber == (short) classNumber; buffer.putShort((short) classNumber); byte[] signature = member.getBytes(Charsets.UTF_8); for (int i = 0; i < signature.length; i++) { // Make sure all signatures are really just simple ASCII byte b = signature[i]; assert b == (b & 0x7f) : member; buffer.put(b); // Skip types on methods if (b == (byte) ')') { break; } } buffer.put((byte) 0); int api = since; assert api == UnsignedBytes.toInt((byte) api); //assert api >= 1 && api < 0xFF; // max that fits in a byte buffer.put((byte) api); nextEntry = buffer.position(); } } int size = buffer.position(); assert size <= buffer.limit(); buffer.mark(); if (WRITE_STATS) { System.out.println("Wrote " + classes.size() + " classes and " + memberCount + " member entries"); System.out.print("Actual binary size: " + size + " bytes"); System.out.println(String.format(" (%.1fM)", size / (1024 * 1024.f))); System.out.println("Allocated size: " + (entryCount * BYTES_PER_ENTRY) + " bytes"); System.out.println("Required bytes per entry: " + (size / entryCount) + " bytes"); } // Now dump this out as a file // There's probably an API to do this more efficiently; TODO: Look into this. byte[] b = new byte[size]; buffer.rewind(); buffer.get(b); if (file.exists()) { file.delete(); } FileOutputStream output = Files.newOutputStreamSupplier(file).getOutput(); output.write(b); output.close(); } // For debugging only private String dumpEntry(int offset) { if (DEBUG_SEARCH) { StringBuilder sb = new StringBuilder(200); for (int i = offset; i < mData.length; i++) { if (mData[i] == 0) { break; } char c = (char) UnsignedBytes.toInt(mData[i]); sb.append(c); } return sb.toString(); } else { return "<disabled>"; //$NON-NLS-1$ } } private static int compare(byte[] data, int offset, byte terminator, String s, int max) { int i = offset; int j = 0; for (; j < max; i++, j++) { byte b = data[i]; char c = s.charAt(j); // TODO: Check somewhere that the strings are purely in the ASCII range; if not // they're not a match in the database byte cb = (byte) c; int delta = b - cb; if (delta != 0) { return delta; } } return data[i] - terminator; } /** * Quick determination whether a given class name is possibly interesting; this * is a quick package prefix check to determine whether we need to consider * the class at all. This let's us do less actual searching for the vast majority * of APIs (in libraries, application code etc) that have nothing to do with the * APIs in our packages. * @param name the class name in VM format (e.g. using / instead of .) * @return true if the owner is <b>possibly</b> relevant */ public static boolean isRelevantClass(String name) { // TODO: Add quick switching here. This is tied to the database file so if // we end up with unexpected prefixes there, this could break. For that reason, // for now we consider everything relevant. return true; } /** * Returns the API version required by the given class reference, * or -1 if this is not a known API class. Note that it may return -1 * for classes introduced in version 1; internally the database only * stores version data for version 2 and up. * * @param className the internal name of the class, e.g. its * fully qualified name (as returned by Class.getName(), but with * '.' replaced by '/'. * @return the minimum API version the method is supported for, or -1 if * it's unknown <b>or version 1</b>. */ public int getClassVersion(@NonNull String className) { if (!isRelevantClass(className)) { return -1; } if (mData != null) { int classNumber = findClass(className); if (classNumber != -1) { int offset = mIndices[classNumber]; while (mData[offset] != 0) { offset++; } offset++; return UnsignedBytes.toInt(mData[offset]); } } else { ApiClass clz = mInfo.getClass(className); if (clz != null) { int since = clz.getSince(); if (since == Integer.MAX_VALUE) { since = -1; } return since; } } return -1; } /** * Returns the API version required by the given method call. The method is * referred to by its {@code owner}, {@code name} and {@code desc} fields. * If the method is unknown it returns -1. Note that it may return -1 for * classes introduced in version 1; internally the database only stores * version data for version 2 and up. * * @param owner the internal name of the method's owner class, e.g. its * fully qualified name (as returned by Class.getName(), but with * '.' replaced by '/'. * @param name the method's name * @param desc the method's descriptor - see {@link org.objectweb.asm.Type} * @return the minimum API version the method is supported for, or -1 if * it's unknown <b>or version 1</b>. */ public int getCallVersion(@NonNull String owner, @NonNull String name, @NonNull String desc) { if (!isRelevantClass(owner)) { return -1; } if (mData != null) { int classNumber = findClass(owner); if (classNumber != -1) { return findMember(classNumber, name, desc); } } else { ApiClass clz = mInfo.getClass(owner); if (clz != null) { String signature = name + desc; int since = clz.getMethod(signature, mInfo); if (since == Integer.MAX_VALUE) { since = -1; } return since; } } return -1; } /** * Returns the API version required to access the given field, or -1 if this * is not a known API method. Note that it may return -1 for classes * introduced in version 1; internally the database only stores version data * for version 2 and up. * * @param owner the internal name of the method's owner class, e.g. its * fully qualified name (as returned by Class.getName(), but with * '.' replaced by '/'. * @param name the method's name * @return the minimum API version the method is supported for, or -1 if * it's unknown <b>or version 1</b> */ public int getFieldVersion(@NonNull String owner, @NonNull String name) { if (!isRelevantClass(owner)) { return -1; } if (mData != null) { int classNumber = findClass(owner); if (classNumber != -1) { return findMember(classNumber, name, null); } } else { ApiClass clz = mInfo.getClass(owner); if (clz != null) { int since = clz.getField(name, mInfo); if (since == Integer.MAX_VALUE) { since = -1; } return since; } } return -1; } /** * Returns true if the given owner (in VM format) is relevant to the database. * This allows quick filtering out of owners that won't return any data * for the various {@code #getFieldVersion} etc methods. * * @param owner the owner to look up * @return true if the owner might be relevant to the API database */ public static boolean isRelevantOwner(@NonNull String owner) { if (owner.startsWith("java")) { //$NON-NLS-1$ // includes javax/ return true; } if (owner.startsWith(ANDROID_PKG)) { return !owner.startsWith("/support/", 7); } else if (owner.startsWith("org/")) { //$NON-NLS-1$ if (owner.startsWith("xml", 4) //$NON-NLS-1$ || owner.startsWith("w3c/", 4) //$NON-NLS-1$ || owner.startsWith("json/", 4) //$NON-NLS-1$ || owner.startsWith("apache/", 4)) { //$NON-NLS-1$ return true; } } else if (owner.startsWith("com/")) { //$NON-NLS-1$ if (owner.startsWith("google/", 4) //$NON-NLS-1$ || owner.startsWith("android/", 4)) { //$NON-NLS-1$ return true; } } else if (owner.startsWith("junit") //$NON-NLS-1$ || owner.startsWith("dalvik")) { //$NON-NLS-1$ return true; } return false; } /** * Returns true if the given owner (in VM format) is a valid Java package supported * in any version of Android. * * @param owner the package, in VM format * @return true if the package is included in one or more versions of Android */ public boolean isValidJavaPackage(@NonNull String owner) { int packageLength = owner.lastIndexOf('/'); if (packageLength == -1) { return false; } // The index array contains class indexes from 0 to classCount and // member indices from classCount to mIndices.length. int low = 0; int high = mJavaPackages.length - 1; while (low <= high) { int middle = (low + high) >>> 1; int offset = middle; if (DEBUG_SEARCH) { System.out.println( "Comparing string " + owner + " with entry at " + offset + ": " + mJavaPackages[offset]); } // Compare the api info at the given index. int compare = comparePackage(mJavaPackages[offset], owner, packageLength); if (compare == 0) { return true; } if (compare < 0) { low = middle + 1; } else if (compare > 0) { high = middle - 1; } else { assert false; // compare == 0 already handled above return false; } } return false; } private static int comparePackage(String s1, String s2, int max) { for (int i = 0; i < max; i++) { if (i == s1.length()) { return -1; } char c1 = s1.charAt(i); char c2 = s2.charAt(i); if (c1 != c2) { return c1 - c2; } } if (s1.length() > max) { return 1; } return 0; } /** Returns the class number of the given class, or -1 if it is unknown */ private int findClass(@NonNull String owner) { assert owner.indexOf('.') == -1 : "Should use / instead of . in owner: " + owner; // The index array contains class indexes from 0 to classCount and // member indices from classCount to mIndices.length. int low = 0; int high = mClassCount - 1; // Compare the api info at the given index. int classNameLength = owner.length(); while (low <= high) { int middle = (low + high) >>> 1; int offset = mIndices[middle]; if (DEBUG_SEARCH) { System.out.println( "Comparing string " + owner + " with entry at " + offset + ": " + dumpEntry(offset)); } int compare = compare(mData, offset, (byte) 0, owner, classNameLength); if (compare == 0) { return middle; } if (compare < 0) { low = middle + 1; } else if (compare > 0) { high = middle - 1; } else { assert false; // compare == 0 already handled above return -1; } } return -1; } private int findMember(int classNumber, @NonNull String name, @Nullable String desc) { // The index array contains class indexes from 0 to classCount and // member indices from classCount to mIndices.length. int low = mClassCount; int high = mIndices.length - 1; while (low <= high) { int middle = (low + high) >>> 1; int offset = mIndices[middle]; if (DEBUG_SEARCH) { System.out.println("Comparing string " + (name + ';' + desc) + " with entry at " + offset + ": " + dumpEntry(offset)); } // Check class number: read short. The byte data is always big endian. int entryClass = (mData[offset++] & 0xFF) << 8 | (mData[offset++] & 0xFF); int compare = entryClass - classNumber; if (compare == 0) { if (desc != null) { // Method int nameLength = name.length(); compare = compare(mData, offset, (byte) '(', name, nameLength); if (compare == 0) { offset += nameLength; int argsEnd = desc.indexOf(')'); // Only compare up to the ) -- after that we have a return value in the // input description, which isn't there in the database compare = compare(mData, offset, (byte) ')', desc, argsEnd); if (compare == 0) { offset += argsEnd + 1; if (mData[offset++] == 0) { // Yes, terminated argument list: get the API level return UnsignedBytes.toInt(mData[offset]); } } } } else { // Field int nameLength = name.length(); compare = compare(mData, offset, (byte) 0, name, nameLength); if (compare == 0) { offset += nameLength; if (mData[offset++] == 0) { // Yes, terminated argument list: get the API level return UnsignedBytes.toInt(mData[offset]); } } } } if (compare < 0) { low = middle + 1; } else if (compare > 0) { high = middle - 1; } else { assert false; // compare == 0 already handled above return -1; } } return -1; } /** Clears out any existing lookup instances */ @VisibleForTesting static void dispose() { sInstance.clear(); } }