1 /* 2 * Copyright (C) 2006 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package android.app; 18 19 import android.annotation.UnsupportedAppUsage; 20 import android.content.pm.SharedLibraryInfo; 21 import android.os.Build; 22 import android.os.GraphicsEnvironment; 23 import android.os.Trace; 24 import android.util.ArrayMap; 25 import android.util.Log; 26 27 import com.android.internal.os.ClassLoaderFactory; 28 29 import dalvik.system.PathClassLoader; 30 31 import java.util.ArrayList; 32 import java.util.Collection; 33 import java.util.HashMap; 34 import java.util.List; 35 import java.util.Map; 36 37 /** @hide */ 38 public class ApplicationLoaders { 39 private static final String TAG = "ApplicationLoaders"; 40 41 @UnsupportedAppUsage getDefault()42 public static ApplicationLoaders getDefault() { 43 return gApplicationLoaders; 44 } 45 getClassLoader(String zip, int targetSdkVersion, boolean isBundled, String librarySearchPath, String libraryPermittedPath, ClassLoader parent, String classLoaderName)46 ClassLoader getClassLoader(String zip, int targetSdkVersion, boolean isBundled, 47 String librarySearchPath, String libraryPermittedPath, 48 ClassLoader parent, String classLoaderName) { 49 return getClassLoaderWithSharedLibraries(zip, targetSdkVersion, isBundled, 50 librarySearchPath, libraryPermittedPath, parent, classLoaderName, 51 null); 52 } 53 getClassLoaderWithSharedLibraries( String zip, int targetSdkVersion, boolean isBundled, String librarySearchPath, String libraryPermittedPath, ClassLoader parent, String classLoaderName, List<ClassLoader> sharedLibraries)54 ClassLoader getClassLoaderWithSharedLibraries( 55 String zip, int targetSdkVersion, boolean isBundled, 56 String librarySearchPath, String libraryPermittedPath, 57 ClassLoader parent, String classLoaderName, 58 List<ClassLoader> sharedLibraries) { 59 // For normal usage the cache key used is the same as the zip path. 60 return getClassLoader(zip, targetSdkVersion, isBundled, librarySearchPath, 61 libraryPermittedPath, parent, zip, classLoaderName, sharedLibraries); 62 } 63 64 /** 65 * Gets a class loader for a shared library. Additional dependent shared libraries are allowed 66 * to be specified (sharedLibraries). 67 * 68 * Additionally, as an optimization, this will return a pre-created ClassLoader if one has 69 * been cached by createAndCacheNonBootclasspathSystemClassLoaders. 70 */ getSharedLibraryClassLoaderWithSharedLibraries(String zip, int targetSdkVersion, boolean isBundled, String librarySearchPath, String libraryPermittedPath, ClassLoader parent, String classLoaderName, List<ClassLoader> sharedLibraries)71 ClassLoader getSharedLibraryClassLoaderWithSharedLibraries(String zip, int targetSdkVersion, 72 boolean isBundled, String librarySearchPath, String libraryPermittedPath, 73 ClassLoader parent, String classLoaderName, List<ClassLoader> sharedLibraries) { 74 ClassLoader loader = getCachedNonBootclasspathSystemLib(zip, parent, classLoaderName, 75 sharedLibraries); 76 if (loader != null) { 77 return loader; 78 } 79 80 return getClassLoaderWithSharedLibraries(zip, targetSdkVersion, isBundled, 81 librarySearchPath, libraryPermittedPath, parent, classLoaderName, sharedLibraries); 82 } 83 getClassLoader(String zip, int targetSdkVersion, boolean isBundled, String librarySearchPath, String libraryPermittedPath, ClassLoader parent, String cacheKey, String classLoaderName, List<ClassLoader> sharedLibraries)84 private ClassLoader getClassLoader(String zip, int targetSdkVersion, boolean isBundled, 85 String librarySearchPath, String libraryPermittedPath, 86 ClassLoader parent, String cacheKey, 87 String classLoaderName, List<ClassLoader> sharedLibraries) { 88 /* 89 * This is the parent we use if they pass "null" in. In theory 90 * this should be the "system" class loader; in practice we 91 * don't use that and can happily (and more efficiently) use the 92 * bootstrap class loader. 93 */ 94 ClassLoader baseParent = ClassLoader.getSystemClassLoader().getParent(); 95 96 synchronized (mLoaders) { 97 if (parent == null) { 98 parent = baseParent; 99 } 100 101 /* 102 * If we're one step up from the base class loader, find 103 * something in our cache. Otherwise, we create a whole 104 * new ClassLoader for the zip archive. 105 */ 106 if (parent == baseParent) { 107 ClassLoader loader = mLoaders.get(cacheKey); 108 if (loader != null) { 109 return loader; 110 } 111 112 Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, zip); 113 114 ClassLoader classloader = ClassLoaderFactory.createClassLoader( 115 zip, librarySearchPath, libraryPermittedPath, parent, 116 targetSdkVersion, isBundled, classLoaderName, sharedLibraries); 117 118 Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER); 119 120 Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "setLayerPaths"); 121 GraphicsEnvironment.getInstance().setLayerPaths( 122 classloader, librarySearchPath, libraryPermittedPath); 123 Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER); 124 125 if (cacheKey != null) { 126 mLoaders.put(cacheKey, classloader); 127 } 128 return classloader; 129 } 130 131 Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, zip); 132 ClassLoader loader = ClassLoaderFactory.createClassLoader( 133 zip, null, parent, classLoaderName, sharedLibraries); 134 Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER); 135 return loader; 136 } 137 } 138 139 /** 140 * Caches system library class loaders which are not on the bootclasspath but are still used 141 * by many system apps. 142 * 143 * All libraries in the closure of libraries to be loaded must be in libs. A library can 144 * only depend on libraries that come before it in the list. 145 */ createAndCacheNonBootclasspathSystemClassLoaders(SharedLibraryInfo[] libs)146 public void createAndCacheNonBootclasspathSystemClassLoaders(SharedLibraryInfo[] libs) { 147 if (mSystemLibsCacheMap != null) { 148 throw new IllegalStateException("Already cached."); 149 } 150 151 mSystemLibsCacheMap = new HashMap<String, CachedClassLoader>(); 152 153 for (SharedLibraryInfo lib : libs) { 154 createAndCacheNonBootclasspathSystemClassLoader(lib); 155 } 156 } 157 158 /** 159 * Caches a single non-bootclasspath class loader. 160 * 161 * All of this library's dependencies must have previously been cached. Otherwise, an exception 162 * is thrown. 163 */ createAndCacheNonBootclasspathSystemClassLoader(SharedLibraryInfo lib)164 private void createAndCacheNonBootclasspathSystemClassLoader(SharedLibraryInfo lib) { 165 String path = lib.getPath(); 166 List<SharedLibraryInfo> dependencies = lib.getDependencies(); 167 168 // get cached classloaders for dependencies 169 ArrayList<ClassLoader> sharedLibraries = null; 170 if (dependencies != null) { 171 sharedLibraries = new ArrayList<ClassLoader>(dependencies.size()); 172 for (SharedLibraryInfo dependency : dependencies) { 173 String dependencyPath = dependency.getPath(); 174 CachedClassLoader cached = mSystemLibsCacheMap.get(dependencyPath); 175 176 if (cached == null) { 177 throw new IllegalStateException("Failed to find dependency " + dependencyPath 178 + " of cachedlibrary " + path); 179 } 180 181 sharedLibraries.add(cached.loader); 182 } 183 } 184 185 // assume cached libraries work with current sdk since they are built-in 186 ClassLoader classLoader = getClassLoader(path, Build.VERSION.SDK_INT, true /*isBundled*/, 187 null /*librarySearchPath*/, null /*libraryPermittedPath*/, null /*parent*/, 188 null /*cacheKey*/, null /*classLoaderName*/, sharedLibraries /*sharedLibraries*/); 189 190 if (classLoader == null) { 191 // bad configuration or break in classloading code 192 throw new IllegalStateException("Failed to cache " + path); 193 } 194 195 CachedClassLoader cached = new CachedClassLoader(); 196 cached.loader = classLoader; 197 cached.sharedLibraries = sharedLibraries; 198 199 Log.d(TAG, "Created zygote-cached class loader: " + path); 200 mSystemLibsCacheMap.put(path, cached); 201 } 202 sharedLibrariesEquals(List<ClassLoader> lhs, List<ClassLoader> rhs)203 private static boolean sharedLibrariesEquals(List<ClassLoader> lhs, List<ClassLoader> rhs) { 204 if (lhs == null) { 205 return rhs == null; 206 } 207 208 return lhs.equals(rhs); 209 } 210 211 /** 212 * Returns lib cached with createAndCacheNonBootclasspathSystemClassLoader. This is called by 213 * the zygote during caching. 214 * 215 * If there is an error or the cache is not available, this returns null. 216 */ getCachedNonBootclasspathSystemLib(String zip, ClassLoader parent, String classLoaderName, List<ClassLoader> sharedLibraries)217 public ClassLoader getCachedNonBootclasspathSystemLib(String zip, ClassLoader parent, 218 String classLoaderName, List<ClassLoader> sharedLibraries) { 219 if (mSystemLibsCacheMap == null) { 220 return null; 221 } 222 223 // we only cache top-level libs with the default class loader 224 if (parent != null || classLoaderName != null) { 225 return null; 226 } 227 228 CachedClassLoader cached = mSystemLibsCacheMap.get(zip); 229 if (cached == null) { 230 return null; 231 } 232 233 // cached must be built and loaded in the same environment 234 if (!sharedLibrariesEquals(sharedLibraries, cached.sharedLibraries)) { 235 Log.w(TAG, "Unexpected environment for cached library: (" + sharedLibraries + "|" 236 + cached.sharedLibraries + ")"); 237 return null; 238 } 239 240 Log.d(TAG, "Returning zygote-cached class loader: " + zip); 241 return cached.loader; 242 } 243 244 /** 245 * Creates a classloader for the WebView APK and places it in the cache of loaders maintained 246 * by this class. This is used in the WebView zygote, where its presence in the cache speeds up 247 * startup and enables memory sharing. 248 */ createAndCacheWebViewClassLoader(String packagePath, String libsPath, String cacheKey)249 public ClassLoader createAndCacheWebViewClassLoader(String packagePath, String libsPath, 250 String cacheKey) { 251 // The correct paths are calculated by WebViewZygote in the system server and passed to 252 // us here. We hardcode the other parameters: WebView always targets the current SDK, 253 // does not need to use non-public system libraries, and uses the base classloader as its 254 // parent to permit usage of the cache. 255 // The cache key is passed separately to enable the stub WebView to be cached under the 256 // stub's APK path, when the actual package path is the donor APK. 257 return getClassLoader(packagePath, Build.VERSION.SDK_INT, false, libsPath, null, null, 258 cacheKey, null /* classLoaderName */, null /* sharedLibraries */); 259 } 260 261 /** 262 * Adds a new path the classpath of the given loader. 263 * @throws IllegalStateException if the provided class loader is not a {@link PathClassLoader}. 264 */ addPath(ClassLoader classLoader, String dexPath)265 void addPath(ClassLoader classLoader, String dexPath) { 266 if (!(classLoader instanceof PathClassLoader)) { 267 throw new IllegalStateException("class loader is not a PathClassLoader"); 268 } 269 final PathClassLoader baseDexClassLoader = (PathClassLoader) classLoader; 270 baseDexClassLoader.addDexPath(dexPath); 271 } 272 273 /** 274 * @hide 275 */ addNative(ClassLoader classLoader, Collection<String> libPaths)276 void addNative(ClassLoader classLoader, Collection<String> libPaths) { 277 if (!(classLoader instanceof PathClassLoader)) { 278 throw new IllegalStateException("class loader is not a PathClassLoader"); 279 } 280 final PathClassLoader baseDexClassLoader = (PathClassLoader) classLoader; 281 baseDexClassLoader.addNativePath(libPaths); 282 } 283 284 @UnsupportedAppUsage 285 private final ArrayMap<String, ClassLoader> mLoaders = new ArrayMap<>(); 286 287 private static final ApplicationLoaders gApplicationLoaders = new ApplicationLoaders(); 288 289 private static class CachedClassLoader { 290 ClassLoader loader; 291 292 /** 293 * The shared libraries used when constructing loader for verification. 294 */ 295 List<ClassLoader> sharedLibraries; 296 } 297 298 /** 299 * This is a map of zip to associated class loader. 300 */ 301 private Map<String, CachedClassLoader> mSystemLibsCacheMap = null; 302 } 303