base/core/java/android/app/LoadedApk.java
135 public LoadedApk(ActivityThreadactivityThread, ApplicationInfo aInfo,
136 CompatibilityInfo compatInfo, ClassLoader baseLoader,
137 boolean securityViolation, boolean includeCode, boolean registerPackage){
138 final int myUid = Process.myUid();
139 aInfo = adjustNativeLibraryPaths(aInfo);
140
141 mActivityThread = activityThread;
142 mApplicationInfo = aInfo;
143 mPackageName = aInfo.packageName;
144 mAppDir = aInfo.sourceDir;
145 mResDir = aInfo.uid == myUid ? aInfo.sourceDir : aInfo.publicSourceDir;
146 mSplitAppDirs = aInfo.splitSourceDirs;
147 mSplitResDirs = aInfo.uid == myUid ?aInfo.splitSourceDirs : aInfo.splitPublicSourceDirs;
148 mOverlayDirs = aInfo.resourceDirs;
149 if (!UserHandle.isSameUser(aInfo.uid, myUid) &&!Process.isIsolated()) {
150 aInfo.dataDir =PackageManager.getDataDirForUser(UserHandle.getUserId(myUid),
151 mPackageName);
152 }
153 mSharedLibraries = aInfo.sharedLibraryFiles;
154 mDataDir = aInfo.dataDir;
155 mDataDirFile = mDataDir != null ? new File(mDataDir) : null;
156 mLibDir = aInfo.nativeLibraryDir;
157 mBaseClassLoader = baseLoader;
158 mSecurityViolation = securityViolation;
159 mIncludeCode = includeCode;
160 mRegisterPackage = registerPackage;
161 mDisplayAdjustments.setCompatibilityInfo(compatInfo);
162 }
542 public Resources getResources(ActivityThreadmainThread) {
543 if (mResources == null) {
544 mResources = mainThread.getTopLevelResources(mResDir,mSplitResDirs, mOverlayDirs,
545 mApplicationInfo.sharedLibraryFiles, Display.DEFAULT_DISPLAY, null,this);
546 }
547 return mResources;
548 }
base/core/java/android/app/ActivityThread.java
1784 Resources getTopLevelResources(StringresDir, String[] splitResDirs, String[] overlayDirs,
1785 String[] libDirs, int displayId,Configuration overrideConfiguration,
1786 LoadedApk pkgInfo) {
1787 return mResourcesManager.getTopLevelResources(resDir,splitResDirs, overlayDirs, libDirs,
1788 displayId,overrideConfiguration, pkgInfo.getCompatibilityInfo(), null);
1789 }
base/core/java/android/app/ResourcesManager.java
152 public Resources getTopLevelResources(StringresDir, String[] splitResDirs,
153 String[] overlayDirs, String[]libDirs, int displayId,
154 ConfigurationoverrideConfiguration, CompatibilityInfo compatInfo, IBinder token) {
155 final float scale = compatInfo.applicationScale;
156 ResourcesKey key = new ResourcesKey(resDir, displayId,overrideConfiguration, scale, token);
157 Resources r;
158 synchronized (this) {
159 // Resources is app scaledependent.
160 if (false) {
161 Slog.w(TAG,"getTopLevelResources: " + resDir + " / " + scale);
162 }
163 WeakReference<Resources> wr= mActiveResources.get(key);
164 r = wr != null ? wr.get() : null;
165 //if (r != null) Slog.i(TAG,"isUpToDate " + resDir + ": " +r.getAssets().isUpToDate());
166 if (r != null &&r.getAssets().isUpToDate()) {
167 if (false) {
168 Slog.w(TAG,"Returning cached resources " + r + " " + resDir
169 + ":appScale=" + r.getCompatibilityInfo().applicationScale);
170 }
171 return r;
172 }
173 }
174
175 //if (r != null) {
176 // Slog.w(TAG, "Throwingaway out-of-date resources!!!! "
177 // + r + " "+ resDir);
178 //}
179
180 AssetManager assets = new AssetManager();
181 // resDir can be null if the 'android' package is creating a newResources object.
182 // This is fine, since each AssetManager automatically loads the'android' package
183 // already.
184 if (resDir != null) {
185 if(assets.addAssetPath(resDir) == 0) {
186 return null;
187 }
188 }
189
190 if (splitResDirs != null) {
191 for (String splitResDir :splitResDirs) {
192 if (assets.addAssetPath(splitResDir)== 0) {
193 return null;
194 }
195 }
196 }
197
198 if (overlayDirs != null) {
199 for (String idmapPath :overlayDirs) {
200 assets.addOverlayPath(idmapPath);
201 }
202 }
base/services/core/java/com/android/server/pm/PackageManagerService.java
4450 private boolean createIdmapForPackagePairLI(PackageParser.Packagepkg,
4451 PackageParser.Package opkg) {
4452 if (!opkg.mTrustedOverlay) {
4453 Slog.w(TAG, "Skipping targetand overlay pair " + pkg.baseCodePath + " and " +
4454 opkg.baseCodePath +": overlay not trusted");
4455 return false;
4456 }
4457 HashMap<String, PackageParser.Package> overlaySet =mOverlays.get(pkg.packageName);
4458 if (overlaySet == null) {
4459 Slog.e(TAG, "was about tocreate idmap for " + pkg.baseCodePath + " and " +
4460 opkg.baseCodePath + " but targetpackage has no known overlays");
4461 return false;
4462 }
4463 final int sharedGid =UserHandle.getSharedAppGid(pkg.applicationInfo.uid);
4464 // TODO: generate idmap for split APKs
4465 if (mInstaller.idmap(pkg.baseCodePath, opkg.baseCodePath, sharedGid) !=0) {
4466 Slog.e(TAG, "Failed togenerate idmap for " + pkg.baseCodePath + " and "
4467 + opkg.baseCodePath);
4468 return false;
4469 }
4470 PackageParser.Package[] overlayArray =
4471 overlaySet.values().toArray(newPackageParser.Package[0]);
4472 Comparator<PackageParser.Package> cmp = newComparator<PackageParser.Package>() {
4473 public intcompare(PackageParser.Package p1, PackageParser.Package p2) {
4474 return p1.mOverlayPriority -p2.mOverlayPriority;
4475 }
4476 };
4477 Arrays.sort(overlayArray, cmp);
4478
4479 pkg.applicationInfo.resourceDirs = newString[overlayArray.length];
4480 int i = 0;
4481 for (PackageParser.Package p : overlayArray) {
4482 pkg.applicationInfo.resourceDirs[i++] = p.baseCodePath;
4483 }
4484 return true;
4485 }
5634 private PackageParser.Package scanPackageDirtyLI(PackageParser.Packagepkg, int parseFlags,
5635 int scanFlags, long currentTime,UserHandle user) throws PackageManagerException {
5636 final File scanFile = new File(pkg.codePath);
5637 if (pkg.applicationInfo.getCodePath() == null ||
5638 pkg.applicationInfo.getResourcePath() == null) {
5639 // Bail out. The resource and codepaths haven't been set.
5640 throw newPackageManagerException(INSTALL_FAILED_INVALID_APK,
5641 "Code and resourcepaths haven't been set correctly");
5642 }
……
6780 // Create idmap files for pairs of(packages, overlay packages).
6781 // Note: "android", ieframework-res.apk, is handled by native layers.
6782 if (pkg.mOverlayTarget != null) {
6783 // This is an overlay package.
6784 if (pkg.mOverlayTarget != null&& !pkg.mOverlayTarget.equals("android")) {
6785 if(!mOverlays.containsKey(pkg.mOverlayTarget)) {
6786 mOverlays.put(pkg.mOverlayTarget,
6787 new HashMap<String,PackageParser.Package>());
6788 }
6789 HashMap<String,PackageParser.Package> map = mOverlays.get(pkg.mOverlayTarget);
6790 map.put(pkg.packageName,pkg);
6791 PackageParser.Package orig= mPackages.get(pkg.mOverlayTarget);
6792 if (orig != null&& !createIdmapForPackagePairLI(orig, pkg)){
6793 throw newPackageManagerException(INSTALL_FAILED_UPDATE_INCOMPATIBLE,
6794 "scanPackageLI failed to createIdmap");
6795 }
6796 }
6797 } else if(mOverlays.containsKey(pkg.packageName) &&
6798 !pkg.packageName.equals("android")){
6799 // This is a regular package,with one or more known overlay packages.
6800 createIdmapsForPackageLI(pkg);
6801 }
base/core/java/android/content/pm/PackageParser.java
1429 private Package parseBaseApk(Resourcesres, XmlResourceParser parser, int flags,
1430 String[] outError) throwsXmlPullParserException, IOException {
1431 final boolean trustedOverlay = (flags & PARSE_TRUSTED_OVERLAY) != 0;
1432
1433 AttributeSet attrs = parser;
1434
1435 mParseInstrumentationArgs = null;
1436 mParseActivityArgs = null;
1437 mParseServiceArgs = null;
1438 mParseProviderArgs = null;
1439
1440 final String pkgName;
1441 final String splitName;
1538 } else if(tagName.equals("overlay")) {
1539 pkg.mTrustedOverlay =trustedOverlay;
1540
1541 sa =res.obtainAttributes(attrs,
1542 com.android.internal.R.styleable.AndroidManifestResourceOverlay);
1543 pkg.mOverlayTarget =sa.getString(
1544 com.android.internal.R.styleable.AndroidManifestResourceOverlay_targetPackage);
1545 pkg.mOverlayPriority =sa.getInt(
1546 com.android.internal.R.styleable.AndroidManifestResourceOverlay_priority,
1547 -1);
1548 sa.recycle();
1549
1550 if (pkg.mOverlayTarget ==null) {
1551 outError[0] ="<overlay> does not specify a target package";
1552 mParseError =PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
1553 return null;
1554 }
1555 if (pkg.mOverlayPriority < 0 ||pkg.mOverlayPriority > 9999) {
1556 outError[0] ="<overlay> priority must be between 0 and 9999";
1557 mParseError =
1558 PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
1559 return null;
1560 }
1561 XmlUtils.skipCurrentTag(parser);
base/core/jni/android_util_AssetManager.cpp
1928 static void android_content_AssetManager_init(JNIEnv*env, jobject clazz, jboolean isSystem)
1929 {
1930 if (isSystem) {
1931 verifySystemIdmaps();
1932 }
1933 AssetManager* am = new AssetManager();
1934 if (am == NULL) {
1935 jniThrowException(env, "java/lang/OutOfMemoryError","");
1936 return;
1937 }
1938
1939 am->addDefaultAssets();
1940
1941 ALOGV("Created AssetManager %p for Java object %p\n", am,clazz);
1942 env->SetLongField(clazz, gAssetManagerOffsets.mObject,reinterpret_cast<jlong>(am));
1943 }
338bool AssetManager::addDefaultAssets()
339{
340 const char* root = getenv("ANDROID_ROOT");
341 LOG_ALWAYS_FATAL_IF(root == NULL, "ANDROID_ROOT not set");
342
343 ///M:add for CIP feature @{
344 String8 pathCip(root);
345 pathCip.appendPath(kCIPSystemAssets);
346 FILE *fp;
347 ALOGW("AssetManager-->addDefaultAssets 1");
348 if((fp= fopen(pathCip,"w+"))!= NULL) {
349
350 ALOGW("AssetManager-->addDefaultAssets CIP path exsit!");
351 bool isOK1 = addAssetPath(pathCip, NULL);
352 if(!isOK1){
353 ALOGW("AssetManager-->addDefaultAssets CIP path isok1 isfalse");
354 }
355 String8 pathCip2(root);
356 pathCip2.appendPath(kCIPMediatekAssets);
357 bool isOK2 = addAssetPath(pathCip2, NULL);
186 bool AssetManager::addAssetPath(constString8& path, int32_t* cookie)
187{
188 AutoMutex _l(mLock);
189
190 asset_path ap;
191
192 String8 realPath(path);
193 if (kAppZipName) {
232 mAssetPaths.add(ap);
124 // This is called by zygote (running asuser root) as part of preloadResources.
125 static void verifySystemIdmaps()
126{
127 pid_t pid;
128 char system_id[10];
129
130 snprintf(system_id, sizeof(system_id), "%d", AID_SYSTEM);
131
132 switch (pid = fork()) {
133 case -1:
134 ALOGE("failed to fork for idmap: %s", strerror(errno));
135 break;
136 case 0: // child
137 {
138 struct__user_cap_header_struct capheader;
139 struct __user_cap_data_structcapdata;
140
141 memset(&capheader, 0,sizeof(capheader));
142 memset(&capdata, 0,sizeof(capdata));
143
144 capheader.version =_LINUX_CAPABILITY_VERSION;
145 capheader.pid = 0;
146
147 if (capget(&capheader,&capdata) != 0) {
148 ALOGE("capget:%s\n", strerror(errno));
149 exit(1);
150 }
151
152 capdata.effective =capdata.permitted;
153 if (capset(&capheader,&capdata) != 0) {
154 ALOGE("capset: %s\n",strerror(errno));
155 exit(1);
156 }
157
158 if (setgid(AID_SYSTEM) != 0) {
159 ALOGE("setgid:%s\n", strerror(errno));
160 exit(1);
161 }
162
163 if (setuid(AID_SYSTEM) != 0) {
164 ALOGE("setuid:%s\n", strerror(errno));
165 exit(1);
166 }
167
168 execl(AssetManager::IDMAP_BIN,AssetManager::IDMAP_BIN, "--scan",
169 AssetManager::OVERLAY_DIR, AssetManager::TARGET_PACKAGE_NAME,
170 AssetManager::TARGET_APK_PATH, AssetManager::IDMAP_DIR, (char*)NULL);
171 ALOGE("failed to execlfor idmap: %s", strerror(errno));
172 exit(1); // should never gethere
173 }
174 break;
base/libs/androidfw/AssetManager.cpp
753const ResTable* AssetManager::getResTable(bool required) const
754{
755 ResTable* rt = mResources;
756 if (rt) {
757 return rt;
758 }
781 for (size_t i=0; i<N; i++) {
782 bool empty = appendPathToResTable(mAssetPaths.itemAt(i));
783 onlyEmptyResources = onlyEmptyResources && empty;
784 }
663 boolAssetManager::appendPathToResTable(const asset_path& ap) const {
664 Asset* ass = NULL;
665 ResTable* sharedRes = NULL;
705 #ifdef HAVE_ANDROID_OS
706 const char* data =getenv("ANDROID_DATA");
707 LOG_ALWAYS_FATAL_IF(data ==NULL, "ANDROID_DATA not set");
708 String8overlaysListPath(data);
709 overlaysListPath.appendPath(kResourceCache);
710 overlaysListPath.appendPath("overlays.list");
711 addSystemOverlays(overlaysListPath.string(), ap.path, sharedRes,nextEntryIdx);
712#endif
base/cmds/idmap/scan.cpp
192int idmap_scan(const char *overlay_dir, const char *target_package_name,
193 const char *target_apk_path, constchar *idmap_dir)
194 {
195 String8 filename = String8(idmap_dir);
196 filename.appendPath("overlays.list");
197 if (unlink(filename.string()) != 0 && errno != ENOENT) {
198 return EXIT_FAILURE;
199 }
200
201 DIR *dir = opendir(overlay_dir);
202 if (dir == NULL) {
203 return EXIT_FAILURE;
204 }
205
206 SortedVector<Overlay> overlayVector;
207 struct dirent *dirent;
208 while ((dirent = readdir(dir)) != NULL) {
209 struct stat st;
210 char overlay_apk_path[PATH_MAX + 1];
211 snprintf(overlay_apk_path, PATH_MAX, "%s/%s", overlay_dir,dirent->d_name);
212 if (stat(overlay_apk_path, &st) < 0) {
213 continue;
214 }
215 if (!S_ISREG(st.st_mode)) {
216 continue;
217 }
218
219 int priority = parse_apk(overlay_apk_path, target_package_name);
220 if (priority < 0) {
221 continue;
222 }
223
224 String8 idmap_path(idmap_dir);
225 idmap_path.appendPath(flatten_path(overlay_apk_path + 1));
226 idmap_path.append("@idmap");
227
228 if (idmap_create_path(target_apk_path, overlay_apk_path,idmap_path.string()) != 0) {
229 ALOGE("error: failed tocreate idmap for target=%s overlay=%s idmap=%s\n",
230 target_apk_path,overlay_apk_path, idmap_path.string());
231 continue;
232 }
233
234 Overlay overlay(String8(overlay_apk_path), idmap_path, priority);
235 overlayVector.add(overlay);
236 }
237
238 closedir(dir);
239
240 if (!writePackagesList(filename.string(),overlayVector)) {
241 return EXIT_FAILURE;
242 }
35 bool writePackagesList(const char*filename, const SortedVector<Overlay>&overlayVector)
36 {
37 FILE* fout = fopen(filename, "w");
38 if (fout == NULL) {
39 return false;
40 }
41
42 for (size_t i = 0; i < overlayVector.size(); ++i) {
43 const Overlay& overlay = overlayVector[i];
44 fprintf(fout, "%s %s\n", overlay.apk_path.string(),overlay.idmap_path.string());
45 }
46
47 fclose(fout);
48
49 // Make file world readable since Zygote (running as root) will read
50 // it when creating the initial AssetManger object
51 const mode_t mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH; // 0644
52 if (chmod(filename, mode) == -1) {
53 unlink(filename);
54 return false;
55 }
56
57 return true;
58 }
base/cmds/idmap/idmap.cpp
maybe_scan –> idmap_scan ->
206int main(int argc, char **argv)
207 {
208 #if 0
209 {
210 char buf[1024];
211 buf[0] = '\0';
212 for (int i = 0; i < argc; ++i) {
213 strncat(buf, argv[i], sizeof(buf)- 1);
214 strncat(buf, " ",sizeof(buf) - 1);
215 }
216 ALOGD("%s:%d: uid=%d gid=%d argv=%s\n", __FILE__, __LINE__,getuid(), getgid(), buf);
217 }
218 #endif
219
220 if (argc == 2 && !strcmp(argv[1], "--help")) {
221 printf("%s\n", usage);
222 return 0;
223 }
224
225 if (argc == 5 && !strcmp(argv[1], "--fd")) {
226 return maybe_create_fd(argv[2], argv[3], argv[4]);
227 }
228
229 if (argc == 5 && !strcmp(argv[1], "--path")) {
230 return maybe_create_path(argv[2], argv[3], argv[4]);
231 }
232
233 if (argc == 6&& !strcmp(argv[1], "--scan")) {
234 returnmaybe_scan(argv[2], argv[3], argv[4], argv[5]);
235 }
236
237 if (argc == 3 && !strcmp(argv[1], "--inspect")) {
238 return maybe_inspect(argv[2]);
239 }
240
241 fprintf(stderr, "Usage: don't use this (cf dexopt usage).\n");
242 return EXIT_FAILURE;
243 }