| /* |
| * 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(); |
| } |
| } |
