| /* |
| * Copyright (C) 2011 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 dalvik.system; |
| |
| import java.io.File; |
| import java.io.IOException; |
| import java.net.MalformedURLException; |
| import java.net.URL; |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.Enumeration; |
| import java.util.regex.Pattern; |
| import java.util.zip.ZipFile; |
| |
| /** |
| * A pair of lists of entries, associated with a {@code ClassLoader}. |
| * One of the lists is a dex/resource path — typically referred |
| * to as a "class path" — list, and the other names directories |
| * containing native code libraries. Class path entries may be any of: |
| * a {@code .jar} or {@code .zip} file containing an optional |
| * top-level {@code classes.dex} file as well as arbitrary resources, |
| * or a plain {@code .dex} file (with no possibility of associated |
| * resources). |
| * |
| * <p>This class also contains methods to use these lists to look up |
| * classes and resources.</p> |
| */ |
| /*package*/ final class DexPathList { |
| private static final String DEX_SUFFIX = ".dex"; |
| private static final String JAR_SUFFIX = ".jar"; |
| private static final String ZIP_SUFFIX = ".zip"; |
| private static final String APK_SUFFIX = ".apk"; |
| |
| /** class definition context */ |
| private final ClassLoader definingContext; |
| |
| /** list of dex/resource (class path) elements */ |
| private final Element[] dexElements; |
| |
| /** list of native library directory elements */ |
| private final File[] nativeLibraryDirectories; |
| |
| /** |
| * Constructs an instance. |
| * |
| * @param definingContext the context in which any as-yet unresolved |
| * classes should be defined |
| * @param dexPath list of dex/resource path elements, separated by |
| * {@code File.pathSeparator} |
| * @param libraryPath list of native library directory path elements, |
| * separated by {@code File.pathSeparator} |
| * @param optimizedDirectory directory where optimized {@code .dex} files |
| * should be found and written to, or {@code null} to use the default |
| * system directory for same |
| */ |
| public DexPathList(ClassLoader definingContext, String dexPath, |
| String libraryPath, File optimizedDirectory) { |
| if (definingContext == null) { |
| throw new NullPointerException("definingContext == null"); |
| } |
| |
| if (dexPath == null) { |
| throw new NullPointerException("dexPath == null"); |
| } |
| |
| if (optimizedDirectory != null) { |
| if (!optimizedDirectory.exists()) { |
| throw new IllegalArgumentException( |
| "optimizedDirectory doesn't exist: " |
| + optimizedDirectory); |
| } |
| |
| if (!(optimizedDirectory.canRead() |
| && optimizedDirectory.canWrite())) { |
| throw new IllegalArgumentException( |
| "optimizedDirectory not readable/writable: " |
| + optimizedDirectory); |
| } |
| } |
| |
| this.definingContext = definingContext; |
| this.dexElements = |
| makeDexElements(splitDexPath(dexPath), optimizedDirectory); |
| this.nativeLibraryDirectories = splitLibraryPath(libraryPath); |
| } |
| |
| /** |
| * Splits the given dex path string into elements using the path |
| * separator, pruning out any elements that do not refer to existing |
| * and readable files. (That is, directories are not included in the |
| * result.) |
| */ |
| private static ArrayList<File> splitDexPath(String path) { |
| return splitPaths(path, null, false); |
| } |
| |
| /** |
| * Splits the given library directory path string into elements |
| * using the path separator ({@code File.pathSeparator}, which |
| * defaults to {@code ":"} on Android, appending on the elements |
| * from the system library path, and pruning out any elements that |
| * do not refer to existing and readable directories. |
| */ |
| private static File[] splitLibraryPath(String path) { |
| /* |
| * Native libraries may exist in both the system and |
| * application library paths, and we use this search order: |
| * |
| * 1. this class loader's library path for application |
| * libraries |
| * 2. the VM's library path from the system |
| * property for system libraries |
| * |
| * This order was reversed prior to Gingerbread; see http://b/2933456. |
| */ |
| ArrayList<File> result = splitPaths( |
| path, System.getProperty("java.library.path", "."), true); |
| return result.toArray(new File[result.size()]); |
| } |
| |
| /** |
| * Splits the given path strings into file elements using the path |
| * separator, combining the results and filtering out elements |
| * that don't exist, aren't readable, or aren't either a regular |
| * file or a directory (as specified). Either string may be empty |
| * or {@code null}, in which case it is ignored. If both strings |
| * are empty or {@code null}, or all elements get pruned out, then |
| * this returns a zero-element list. |
| */ |
| private static ArrayList<File> splitPaths(String path1, String path2, |
| boolean wantDirectories) { |
| ArrayList<File> result = new ArrayList<File>(); |
| |
| splitAndAdd(path1, wantDirectories, result); |
| splitAndAdd(path2, wantDirectories, result); |
| return result; |
| } |
| |
| /** |
| * Helper for {@link #splitPaths}, which does the actual splitting |
| * and filtering and adding to a result. |
| */ |
| private static void splitAndAdd(String path, boolean wantDirectories, |
| ArrayList<File> resultList) { |
| if (path == null) { |
| return; |
| } |
| |
| String[] strings = path.split(Pattern.quote(File.pathSeparator)); |
| |
| for (String s : strings) { |
| File file = new File(s); |
| |
| if (! (file.exists() && file.canRead())) { |
| continue; |
| } |
| |
| /* |
| * Note: There are other entities in filesystems than |
| * regular files and directories. |
| */ |
| if (wantDirectories) { |
| if (!file.isDirectory()) { |
| continue; |
| } |
| } else { |
| if (!file.isFile()) { |
| continue; |
| } |
| } |
| |
| resultList.add(file); |
| } |
| } |
| |
| /** |
| * Makes an array of dex/resource path elements, one per element of |
| * the given array. |
| */ |
| private static Element[] makeDexElements(ArrayList<File> files, |
| File optimizedDirectory) { |
| ArrayList<Element> elements = new ArrayList<Element>(); |
| |
| /* |
| * Open all files and load the (direct or contained) dex files |
| * up front. |
| */ |
| for (File file : files) { |
| ZipFile zip = null; |
| DexFile dex = null; |
| String name = file.getName(); |
| |
| if (name.endsWith(DEX_SUFFIX)) { |
| // Raw dex file (not inside a zip/jar). |
| try { |
| dex = loadDexFile(file, optimizedDirectory); |
| } catch (IOException ex) { |
| System.logE("Unable to load dex file: " + file, ex); |
| } |
| } else if (name.endsWith(APK_SUFFIX) || name.endsWith(JAR_SUFFIX) |
| || name.endsWith(ZIP_SUFFIX)) { |
| try { |
| zip = new ZipFile(file); |
| } catch (IOException ex) { |
| /* |
| * Note: ZipException (a subclass of IOException) |
| * might get thrown by the ZipFile constructor |
| * (e.g. if the file isn't actually a zip/jar |
| * file). |
| */ |
| System.logE("Unable to open zip file: " + file, ex); |
| } |
| |
| try { |
| dex = loadDexFile(file, optimizedDirectory); |
| } catch (IOException ignored) { |
| /* |
| * IOException might get thrown "legitimately" by |
| * the DexFile constructor if the zip file turns |
| * out to be resource-only (that is, no |
| * classes.dex file in it). Safe to just ignore |
| * the exception here, and let dex == null. |
| */ |
| } |
| } else { |
| System.logW("Unknown file type for: " + file); |
| } |
| |
| if ((zip != null) || (dex != null)) { |
| elements.add(new Element(file, zip, dex)); |
| } |
| } |
| |
| return elements.toArray(new Element[elements.size()]); |
| } |
| |
| /** |
| * Constructs a {@code DexFile} instance, as appropriate depending |
| * on whether {@code optimizedDirectory} is {@code null}. |
| */ |
| private static DexFile loadDexFile(File file, File optimizedDirectory) |
| throws IOException { |
| if (optimizedDirectory == null) { |
| return new DexFile(file); |
| } else { |
| String optimizedPath = optimizedPathFor(file, optimizedDirectory); |
| return DexFile.loadDex(file.getPath(), optimizedPath, 0); |
| } |
| } |
| |
| /** |
| * Converts a dex/jar file path and an output directory to an |
| * output file path for an associated optimized dex file. |
| */ |
| private static String optimizedPathFor(File path, |
| File optimizedDirectory) { |
| /* |
| * Get the filename component of the path, and replace the |
| * suffix with ".dex" if that's not already the suffix. |
| * |
| * We don't want to use ".odex", because the build system uses |
| * that for files that are paired with resource-only jar |
| * files. If the VM can assume that there's no classes.dex in |
| * the matching jar, it doesn't need to open the jar to check |
| * for updated dependencies, providing a slight performance |
| * boost at startup. The use of ".dex" here matches the use on |
| * files in /data/dalvik-cache. |
| */ |
| String fileName = path.getName(); |
| if (!fileName.endsWith(DEX_SUFFIX)) { |
| int lastDot = fileName.lastIndexOf("."); |
| if (lastDot < 0) { |
| fileName += DEX_SUFFIX; |
| } else { |
| StringBuilder sb = new StringBuilder(lastDot + 4); |
| sb.append(fileName, 0, lastDot); |
| sb.append(DEX_SUFFIX); |
| fileName = sb.toString(); |
| } |
| } |
| |
| File result = new File(optimizedDirectory, fileName); |
| return result.getPath(); |
| } |
| |
| /** |
| * Finds the named class in one of the dex files pointed at by |
| * this instance. This will find the one in the earliest listed |
| * path element. If the class is found but has not yet been |
| * defined, then this method will define it in the defining |
| * context that this instance was constructed with. |
| * |
| * @return the named class or {@code null} if the class is not |
| * found in any of the dex files |
| */ |
| public Class findClass(String name) { |
| for (Element element : dexElements) { |
| DexFile dex = element.dexFile; |
| |
| if (dex != null) { |
| Class clazz = dex.loadClassBinaryName(name, definingContext); |
| if (clazz != null) { |
| return clazz; |
| } |
| } |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Finds the named resource in one of the zip/jar files pointed at |
| * by this instance. This will find the one in the earliest listed |
| * path element. |
| * |
| * @return a URL to the named resource or {@code null} if the |
| * resource is not found in any of the zip/jar files |
| */ |
| public URL findResource(String name) { |
| for (Element element : dexElements) { |
| URL url = element.findResource(name); |
| if (url != null) { |
| return url; |
| } |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Finds all the resources with the given name, returning an |
| * enumeration of them. If there are no resources with the given |
| * name, then this method returns an empty enumeration. |
| */ |
| public Enumeration<URL> findResources(String name) { |
| ArrayList<URL> result = new ArrayList<URL>(); |
| |
| for (Element element : dexElements) { |
| URL url = element.findResource(name); |
| if (url != null) { |
| result.add(url); |
| } |
| } |
| |
| return Collections.enumeration(result); |
| } |
| |
| /** |
| * Finds the named native code library on any of the library |
| * directories pointed at by this instance. This will find the |
| * one in the earliest listed directory, ignoring any that are not |
| * readable regular files. |
| * |
| * @return the complete path to the library or {@code null} if no |
| * library was found |
| */ |
| public String findLibrary(String libraryName) { |
| String fileName = System.mapLibraryName(libraryName); |
| |
| for (File directory : nativeLibraryDirectories) { |
| File file = new File(directory, fileName); |
| if (file.exists() && file.isFile() && file.canRead()) { |
| return file.getPath(); |
| } |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Element of the dex/resource file path |
| */ |
| /*package*/ static class Element { |
| public final File file; |
| public final ZipFile zipFile; |
| public final DexFile dexFile; |
| |
| public Element(File file, ZipFile zipFile, DexFile dexFile) { |
| this.file = file; |
| this.zipFile = zipFile; |
| this.dexFile = dexFile; |
| } |
| |
| public URL findResource(String name) { |
| if ((zipFile == null) || (zipFile.getEntry(name) == null)) { |
| /* |
| * Either this element has no zip/jar file (first |
| * clause), or the zip/jar file doesn't have an entry |
| * for the given name (second clause). |
| */ |
| return null; |
| } |
| |
| try { |
| /* |
| * File.toURL() is compliant with RFC 1738 in |
| * always creating absolute path names. If we |
| * construct the URL by concatenating strings, we |
| * might end up with illegal URLs for relative |
| * names. |
| */ |
| return new URL("jar:" + file.toURL() + "!/" + name); |
| } catch (MalformedURLException ex) { |
| throw new RuntimeException(ex); |
| } |
| } |
| } |
| } |