1
2
3

public static String getConfig(Context systemContext) {
    return systemContext.getResources().getString(R.string.config_xxxxxx);
}

1

<string name="config_xxxxxx"></string>

1

<string name="config_xxxxxx">From RRO</string>

1
2

Resources res = Resouces.getSystem();
print(res.getString(res.getIdentifier("config_xxxxxx", "string", "android")));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public static Resources getSystem() {
    synchronized (sSync) {
        Resources ret = mSystem;
        if (ret == null) {
            ret = new Resources();
            mSystem = ret;
        }
        return ret;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

@UnsupportedAppUsage
private Resources() {
    mClassLoader = ClassLoader.getSystemClassLoader();
    sResourcesHistory.add(this);

    final DisplayMetrics metrics = new DisplayMetrics();
    metrics.setToDefaults();

    final Configuration config = new Configuration();
    config.setToDefaults();

    mResourcesImpl = new ResourcesImpl(AssetManager.getSystem(), metrics, config,
            new DisplayAdjustments());
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

@UnsupportedAppUsage
public static AssetManager getSystem() {
    synchronized (sSync) {
        createSystemAssetsInZygoteLocked(false, FRAMEWORK_APK_PATH);
        return sSystem;
    }
}





@GuardedBy("sSync")
@VisibleForTesting
public static void createSystemAssetsInZygoteLocked(boolean reinitialize,
        String frameworkPath) {
    if (sSystem != null && !reinitialize) {
        return;
    }

    try {
        final ArrayList<ApkAssets> apkAssets = new ArrayList<>();
        apkAssets.add(ApkAssets.loadFromPath(frameworkPath, ApkAssets.PROPERTY_SYSTEM));

        
        final String[] systemIdmapPaths =
                RavenwoodEnvironment.getInstance().isRunningOnRavenwood() ? new String[0] :
                OverlayConfig.getZygoteInstance().createImmutableFrameworkIdmapsInZygote();
        for (String idmapPath : systemIdmapPaths) {
            apkAssets.add(ApkAssets.loadOverlayFromPath(idmapPath, ApkAssets.PROPERTY_SYSTEM));
        }

        sSystemApkAssetsSet = new ArraySet<>(apkAssets);
        sSystemApkAssets = apkAssets.toArray(new ApkAssets[0]);
        if (sSystem == null) {
            sSystem = new AssetManager(true );
        }
        sSystem.setApkAssets(sSystemApkAssets, false );
    } catch (IOException e) {
        throw new IllegalStateException("Failed to create system AssetManager", e);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

@VisibleForTesting
public OverlayConfig(@Nullable File rootDirectory,
        @Nullable Supplier<OverlayScanner> scannerFactory,
        @Nullable PackageProvider packageProvider) {
    Preconditions.checkArgument((scannerFactory == null) != (packageProvider == null),
            "scannerFactory and packageProvider cannot be both null or both non-null");

    final ArrayList<OverlayPartition> partitions;
    if (rootDirectory == null) {
        partitions = new ArrayList<>(
                PackagePartitions.getOrderedPartitions(OverlayPartition::new));
    } else {
        
        partitions = new ArrayList<>(PackagePartitions.getOrderedPartitions(
                p -> new OverlayPartition(
                        new File(rootDirectory, p.getNonConicalFolder().getPath()),
                        p)));
    }
    mIsDefaultPartitionOrder = !sortPartitions(PARTITION_ORDER_FILE_PATH, partitions);
    mPartitionOrder = generatePartitionOrderString(partitions);

    ArrayMap<Integer, List<String>> activeApexesPerPartition = getActiveApexes(partitions);

    final Map<String, ParsedOverlayInfo> packageManagerOverlayInfos =
            packageProvider == null ? null : getOverlayPackageInfos(packageProvider);

    final ArrayList<ParsedConfiguration> overlays = new ArrayList<>();
    for (int i = 0, n = partitions.size(); i < n; i++) {
        final OverlayPartition partition = partitions.get(i);
        final OverlayScanner scanner = (scannerFactory == null) ? null : scannerFactory.get();
        final ArrayList<ParsedConfiguration> partitionOverlays =
                OverlayConfigParser.getConfigurations(partition, scanner,
                        packageManagerOverlayInfos,
                        activeApexesPerPartition.getOrDefault(partition.type,
                                Collections.emptyList()));
        if (partitionOverlays != null) {
            overlays.addAll(partitionOverlays);
            continue;
        }

        
        
        
        
        final ArrayList<ParsedOverlayInfo> partitionOverlayInfos;
        if (scannerFactory != null) {
            partitionOverlayInfos = new ArrayList<>(scanner.getAllParsedInfos());
        } else {
            
            partitionOverlayInfos = new ArrayList<>(packageManagerOverlayInfos.values());
            for (int j = partitionOverlayInfos.size() - 1; j >= 0; j--) {
                if (!partition.containsFile(partitionOverlayInfos.get(j)
                        .getOriginalPartitionPath())) {
                    partitionOverlayInfos.remove(j);
                }
            }
        }

        
        final ArrayList<ParsedConfiguration> partitionConfigs = new ArrayList<>();
        for (int j = 0, m = partitionOverlayInfos.size(); j < m; j++) {
            final ParsedOverlayInfo p = partitionOverlayInfos.get(j);
            if (p.isStatic) {
                partitionConfigs.add(new ParsedConfiguration(p.packageName,
                        true , false , partition.policy, p, null));
            }
        }

        partitionConfigs.sort(sStaticOverlayComparator);
        overlays.addAll(partitionConfigs);
    }

    for (int i = 0, n = overlays.size(); i < n; i++) {
        
        
        
        final ParsedConfiguration config = overlays.get(i);
        mConfigurations.put(config.packageName, new Configuration(config, i));
    }
}





@VisibleForTesting
public ArrayList<IdmapInvocation> getImmutableFrameworkOverlayIdmapInvocations() {
    final ArrayList<IdmapInvocation> idmapInvocations = new ArrayList<>();
    final ArrayList<Configuration> sortedConfigs = getSortedOverlays();
    for (int i = 0, n = sortedConfigs.size(); i < n; i++) {
        final Configuration overlay = sortedConfigs.get(i);
        if (overlay.parsedConfig.mutable || !overlay.parsedConfig.enabled
                || !"android".equals(overlay.parsedConfig.parsedInfo.targetPackageName)) {
            continue;
        }

        
        
        
        final boolean enforceOverlayable = overlay.parsedConfig.parsedInfo.targetSdkVersion
                >= Build.VERSION_CODES.Q;

        
        
        IdmapInvocation invocation = null;
        if (!idmapInvocations.isEmpty()) {
            final IdmapInvocation last = idmapInvocations.get(idmapInvocations.size() - 1);
            if (last.enforceOverlayable == enforceOverlayable
                    && last.policy.equals(overlay.parsedConfig.policy)) {
                invocation = last;
            }
        }

        if (invocation == null) {
            invocation = new IdmapInvocation(enforceOverlayable, overlay.parsedConfig.policy);
            idmapInvocations.add(invocation);
        }

        invocation.overlayPaths.add(overlay.parsedConfig.parsedInfo.path.getAbsolutePath());
    }
    return idmapInvocations;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

private static final ArrayList<SystemPartition> SYSTEM_PARTITIONS =
        new ArrayList<>(Arrays.asList(
                new SystemPartition(Environment.getRootDirectory(),
                        PARTITION_SYSTEM, Partition.PARTITION_NAME_SYSTEM,
                        true , false ), 
                new SystemPartition(Environment.getVendorDirectory(),
                        PARTITION_VENDOR, Partition.PARTITION_NAME_VENDOR,
                        true , true ),
                new SystemPartition(Environment.getOdmDirectory(),
                        PARTITION_ODM, Partition.PARTITION_NAME_ODM,
                        true , true ),
                new SystemPartition(Environment.getOemDirectory(),
                        PARTITION_OEM, Partition.PARTITION_NAME_OEM,
                        false , true ),
                new SystemPartition(Environment.getProductDirectory(),
                        PARTITION_PRODUCT, Partition.PARTITION_NAME_PRODUCT,
                        true , true ),
                new SystemPartition(Environment.getSystemExtDirectory(),
                        PARTITION_SYSTEM_EXT, Partition.PARTITION_NAME_SYSTEM_EXT,
                        true , true )));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

public void scanDir(File partitionOverlayDir) {
    if (!partitionOverlayDir.exists() || !partitionOverlayDir.isDirectory()) {
        return;
    }

    if (!partitionOverlayDir.canRead()) {
        Log.w(TAG, "Directory " + partitionOverlayDir + " cannot be read");
        return;
    }

    final File[] files = partitionOverlayDir.listFiles();
    if (files == null) {
        return;
    }

    for (int i = 0; i < files.length; i++) {
        final File f = files[i];
        if (f.isDirectory()) {
            scanDir(f);
        }

        if (!f.isFile() || !f.getPath().endsWith(".apk")) {
            continue;
        }

        final ParsedOverlayInfo info = parseOverlayManifest(f, mExcludedOverlayPackages);
        if (info == null) {
            continue;
        }

        mParsedOverlayInfos.put(info.packageName, info);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

@UnsupportedAppUsage
public static void preloadResources() {
    try {
        final Resources sysRes = Resources.getSystem();
        sysRes.startPreloading();
        if (PRELOAD_RESOURCES) {
            Log.i(TAG, "Preloading resources...");

            long startTime = SystemClock.uptimeMillis();
            TypedArray ar = sysRes.obtainTypedArray(
                    com.android.internal.R.array.preloaded_drawables);
            int numberOfEntries = preloadDrawables(sysRes, ar);
            ar.recycle();
            Log.i(TAG, "...preloaded " + numberOfEntries + " resources in "
                    + (SystemClock.uptimeMillis() - startTime) + "ms.");

            startTime = SystemClock.uptimeMillis();
            ar = sysRes.obtainTypedArray(
                    com.android.internal.R.array.preloaded_color_state_lists);
            numberOfEntries = preloadColorStateLists(sysRes, ar);
            ar.recycle();
            Log.i(TAG, "...preloaded " + numberOfEntries + " resources in "
                    + (SystemClock.uptimeMillis() - startTime) + "ms.");
        }
        sysRes.finishPreloading();
    } catch (RuntimeException e) {
        Log.w(TAG, "Failure preloading resources", e);
    }
}

1
2
3
4

<overlay
    android:priority="1"
    android:targetPackage="android"
    android:isStatic="true"/>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

@NonNull
Set<UserPackage> registerFabricatedOverlay(
        @NonNull final FabricatedOverlayInternal overlay)
        throws OperationFailedException {
    if (FrameworkParsingPackageUtils.validateName(overlay.overlayName,
            false , true ) != null) {
        throw new OperationFailedException(
                "overlay name can only consist of alphanumeric characters, '_', and '.'");
    }

    final FabricatedOverlayInfo info = mIdmapManager.createFabricatedOverlay(overlay);
    if (info == null) {
        throw new OperationFailedException("failed to create fabricated overlay");
    }

    final Set<UserPackage> updatedTargets = new ArraySet<>();
    for (int userId : mSettings.getUsers()) {
        updatedTargets.addAll(registerFabricatedOverlay(info, userId));
    }
    return updatedTargets;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

constexpr std::string_view kIdmapCacheDir = "/data/resource-cache";

Status Idmap2Service::createFabricatedOverlay(
    const os::FabricatedOverlayInternal& overlay,
    std::optional<os::FabricatedOverlayInfo>* _aidl_return) {
  idmap2::FabricatedOverlay::Builder builder(overlay.packageName, overlay.overlayName,
                                             overlay.targetPackageName);
  if (!overlay.targetOverlayable.empty()) {
    builder.SetOverlayable(overlay.targetOverlayable);
  }

  for (const auto& res : overlay.entries) {
    if (res.dataType == Res_value::TYPE_STRING) {
      builder.SetResourceValue(res.resourceName, res.dataType, res.stringData.value(),
            res.configuration.value_or(std::string()));
    } else if (res.binaryData.has_value()) {
      builder.SetResourceValue(res.resourceName, res.binaryData->get(),
                               res.binaryDataOffset, res.binaryDataSize,
                               res.configuration.value_or(std::string()),
                               res.isNinePatch);
    } else {
      builder.SetResourceValue(res.resourceName, res.dataType, res.data,
            res.configuration.value_or(std::string()));
    }
  }

  
  
  std::string path;
  std::string file_name;
  do {
    constexpr size_t kSuffixLength = 4;
    const std::string random_suffix = RandomStringForPath(kSuffixLength);
    file_name = StringPrintf("%s-%s-%s.frro", overlay.packageName.c_str(),
                             overlay.overlayName.c_str(), random_suffix.c_str());
    path = StringPrintf("%s/%s", kIdmapCacheDir.data(), file_name.c_str());

    
    
    const size_t kMaxFileNameLength = 255;
    if (file_name.size() > kMaxFileNameLength) {
      return error(
          base::StringPrintf("fabricated overlay file name '%s' longer than %zu characters",
                             file_name.c_str(), kMaxFileNameLength));
    }
  } while (std::filesystem::exists(path));
  builder.setFrroPath(path);

  const uid_t uid = IPCThreadState::self()->getCallingUid();
  if (!UidHasWriteAccessToPath(uid, path)) {
    return error(base::StringPrintf("will not write to %s: calling uid %d lacks write access",
                                    path.c_str(), uid));
  }

  const auto frro = builder.Build();
  if (!frro) {
    return error(StringPrintf("failed to serialize '%s:%s': %s", overlay.packageName.c_str(),
                              overlay.overlayName.c_str(), frro.GetErrorMessage().c_str()));
  }
  
  umask(kIdmapFilePermissionMask);
  std::ofstream fout(path);
  if (fout.fail()) {
    return error("failed to open frro path " + path);
  }
  auto result = frro->ToBinaryStream(fout);
  if (!result) {
    unlink(path.c_str());
    return error("failed to write to frro path " + path + ": " + result.GetErrorMessage());
  }
  if (fout.fail()) {
    unlink(path.c_str());
    return error("failed to write to frro path " + path);
  }

  os::FabricatedOverlayInfo out_info;
  out_info.packageName = overlay.packageName;
  out_info.overlayName = overlay.overlayName;
  out_info.targetPackageName = overlay.targetPackageName;
  out_info.targetOverlayable = overlay.targetOverlayable;
  out_info.path = path;
  *_aidl_return = out_info;
  return ok();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

@NonNull
ArraySet<UserPackage> updateOverlaysForUser(final int newUserId) {
    if (DEBUG) {
        Slog.d(TAG, "updateOverlaysForUser newUserId=" + newUserId);
    }

    
    final ArraySet<UserPackage> updatedTargets = new ArraySet<>();
    final ArrayMap<String, PackageState> userPackages = mPackageManager.initializeForUser(
            newUserId);
    CollectionUtils.addAll(updatedTargets, removeOverlaysForUser(
            (info) -> !userPackages.containsKey(info.packageName), newUserId));

    final ArraySet<String> overlaidByOthers = new ArraySet<>();
    for (PackageState packageState : userPackages.values()) {
        var pkg = packageState.getAndroidPackage();
        final String overlayTarget = pkg == null ? null : pkg.getOverlayTarget();
        if (!TextUtils.isEmpty(overlayTarget)) {
            overlaidByOthers.add(overlayTarget);
        }
    }

    
    
    for (int i = 0, n = userPackages.size(); i < n; i++) {
        final PackageState packageState = userPackages.valueAt(i);
        var pkg = packageState.getAndroidPackage();
        if (pkg == null) {
            continue;
        }

        var packageName = packageState.getPackageName();
        try {
            CollectionUtils.addAll(updatedTargets,
                    updatePackageOverlays(pkg, newUserId, 0 ));

            
            
            if (overlaidByOthers.contains(packageName)) {
                updatedTargets.add(UserPackage.of(newUserId, packageName));
            }
        } catch (OperationFailedException e) {
            Slog.e(TAG, "failed to initialize overlays of '" + packageName
                    + "' for user " + newUserId + "", e);
        }
    }

    
    
    for (final FabricatedOverlayInfo info : getFabricatedOverlayInfos()) {
        try {
            CollectionUtils.addAll(updatedTargets, registerFabricatedOverlay(
                    info, newUserId));
        } catch (OperationFailedException e) {
            Slog.e(TAG, "failed to initialize fabricated overlay of '" + info.path
                    + "' for user " + newUserId + "", e);
        }
    }

    
    final ArraySet<String> enabledCategories = new ArraySet<>();
    final ArrayMap<String, List<OverlayInfo>> userOverlays =
            mSettings.getOverlaysForUser(newUserId);
    final int userOverlayTargetCount = userOverlays.size();
    for (int i = 0; i < userOverlayTargetCount; i++) {
        final List<OverlayInfo> overlayList = userOverlays.valueAt(i);
        final int overlayCount = overlayList != null ? overlayList.size() : 0;
        for (int j = 0; j < overlayCount; j++) {
            final OverlayInfo oi = overlayList.get(j);
            if (oi.isEnabled()) {
                enabledCategories.add(oi.category);
            }
        }
    }

    
    for (final String defaultOverlay : mDefaultOverlays) {
        try {
            
            
            
            final OverlayIdentifier overlay = new OverlayIdentifier(defaultOverlay);

            final OverlayInfo oi = mSettings.getOverlayInfo(overlay, newUserId);
            if (!enabledCategories.contains(oi.category)) {
                Slog.w(TAG, "Enabling default overlay '" + defaultOverlay + "' for target '"
                        + oi.targetPackageName + "' in category '" + oi.category + "' for user "
                        + newUserId);
                mSettings.setEnabled(overlay, newUserId, true);
                if (updateState(oi, newUserId, 0)) {
                    CollectionUtils.add(updatedTargets,
                            UserPackage.of(oi.userId, oi.targetPackageName));
                }
            }
        } catch (OverlayManagerSettings.BadKeyException e) {
            Slog.e(TAG, "Failed to set default overlay '" + defaultOverlay + "' for user "
                    + newUserId, e);
        }
    }

    cleanStaleResourceCache();
    return updatedTargets;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

Status Idmap2Service::acquireFabricatedOverlayIterator(int32_t* _aidl_return) {
  std::lock_guard l(frro_iter_mutex_);
  if (frro_iter_.has_value()) {
    LOG(WARNING) << "active ffro iterator was not previously released";
  }
  frro_iter_ = std::filesystem::directory_iterator(kIdmapCacheDir);
  if (frro_iter_id_ == std::numeric_limits<int32_t>::max()) {
    frro_iter_id_ = 0;
  } else {
    ++frro_iter_id_;
  }
  *_aidl_return = frro_iter_id_;
  return ok();
}

Status Idmap2Service::nextFabricatedOverlayInfos(int32_t iteratorId,
    std::vector<os::FabricatedOverlayInfo>* _aidl_return) {
  std::lock_guard l(frro_iter_mutex_);

  constexpr size_t kMaxEntryCount = 100;
  if (!frro_iter_.has_value()) {
    return error("no active frro iterator");
  } else if (frro_iter_id_ != iteratorId) {
    return error("incorrect iterator id in a call to next");
  }

  size_t count = 0;
  auto& entry_iter = *frro_iter_;
  auto entry_iter_end = end(*frro_iter_);
  for (; entry_iter != entry_iter_end && count < kMaxEntryCount; ++entry_iter) {
    auto& entry = *entry_iter;
    if (!entry.is_regular_file() || !android::IsFabricatedOverlay(entry.path().native())) {
      continue;
    }

    const auto overlay = FabricatedOverlayContainer::FromPath(entry.path().native());
    if (!overlay) {
      LOG(WARNING) << "Failed to open '" << entry.path() << "': " << overlay.GetErrorMessage();
      continue;
    }

    auto info = (*overlay)->GetManifestInfo();
    os::FabricatedOverlayInfo out_info;
    out_info.packageName = std::move(info.package_name);
    out_info.overlayName = std::move(info.name);
    out_info.targetPackageName = std::move(info.target_package);
    out_info.targetOverlayable = std::move(info.target_name);
    out_info.path = entry.path();
    _aidl_return->emplace_back(std::move(out_info));
    count++;
  }
  return ok();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

@NonNull
private List<String> updatePackageManagerLocked(@NonNull Collection<String> targetPackageNames,
        final int userId) {
    try {
        traceBegin(TRACE_TAG_RRO, "OMS#updatePackageManagerLocked " + targetPackageNames);
        if (DEBUG) {
            Slog.d(TAG, "Update package manager about changed overlays");
        }
        final PackageManagerInternal pm =
                LocalServices.getService(PackageManagerInternal.class);
        final boolean updateFrameworkRes = targetPackageNames.contains("android");
        if (updateFrameworkRes) {
            targetPackageNames = pm.getTargetPackageNames(userId);
        }

        final ArrayMap<String, OverlayPaths> pendingChanges =
                new ArrayMap<>(targetPackageNames.size());
        synchronized (mLock) {
            final OverlayPaths frameworkOverlays =
                    mImpl.getEnabledOverlayPaths("android", userId, false);
            for (final String targetPackageName : targetPackageNames) {
                final var list = new OverlayPaths.Builder(frameworkOverlays);
                if (!"android".equals(targetPackageName)) {
                    list.addAll(mImpl.getEnabledOverlayPaths(targetPackageName, userId, true));
                }
                pendingChanges.put(targetPackageName, list.build());
            }
        }

        final HashSet<String> updatedPackages = new HashSet<>();
        final HashSet<String> invalidPackages = new HashSet<>();
        pm.setEnabledOverlayPackages(userId, pendingChanges, updatedPackages, invalidPackages);
        return new ArrayList<>(updatedPackages);
    } finally {
        traceEnd(TRACE_TAG_RRO);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

@UnsupportedAppUsage
public String[] resourceDirs;







public String[] overlayPaths;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

@UnsupportedAppUsage
public Resources getResources() {
    if (mResources == null) {
        final String[] splitPaths;
        try {
            splitPaths = getSplitPaths(null);
        } catch (NameNotFoundException e) {
            
            throw new AssertionError("null split not found");
        }

        if (Process.myUid() == mApplicationInfo.uid) {
            ResourcesManager.getInstance().initializeApplicationPaths(mResDir, splitPaths);
        }

        mResources = ResourcesManager.getInstance().getResources(null, mResDir,
                splitPaths, mLegacyOverlayDirs, mOverlayPaths,
                mApplicationInfo.sharedLibraryFiles, null, null, getCompatibilityInfo(),
                getClassLoader(), null);
    }
    return mResources;
}

1
2
3
4
5
6
7
8
9

if (userId == UserHandle.USER_SYSTEM) {
    
    
    for (int i = 0; i < numberOfPendingChanges; i++) {
        final String targetPackageName = pendingChanges.keyAt(i);
        final OverlayPaths newOverlayPaths = pendingChanges.valueAt(i);
        maybeUpdateSystemOverlays(targetPackageName, newOverlayPaths);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

private void maybeUpdateSystemOverlays(String targetPackageName, OverlayPaths newOverlayPaths) {
    if (!mResolverReplaced) {
        if (targetPackageName.equals("android")) {
            if (newOverlayPaths == null) {
                mPlatformPackageOverlayPaths = null;
                mPlatformPackageOverlayResourceDirs = null;
            } else {
                mPlatformPackageOverlayPaths = newOverlayPaths.getOverlayPaths().toArray(
                        new String[0]);
                mPlatformPackageOverlayResourceDirs = newOverlayPaths.getResourceDirs().toArray(
                        new String[0]);
            }
            applyUpdatedSystemOverlayPaths();
        }
    } else {
        if (targetPackageName.equals(mResolveActivity.applicationInfo.packageName)) {
            if (newOverlayPaths == null) {
                mReplacedResolverPackageOverlayPaths = null;
                mReplacedResolverPackageOverlayResourceDirs = null;
            } else {
                mReplacedResolverPackageOverlayPaths =
                        newOverlayPaths.getOverlayPaths().toArray(new String[0]);
                mReplacedResolverPackageOverlayResourceDirs =
                        newOverlayPaths.getResourceDirs().toArray(new String[0]);
            }
            applyUpdatedSystemOverlayPaths();
        }
    }
}

private void applyUpdatedSystemOverlayPaths() {
    if (mAndroidApplication == null) {
        Slog.i(TAG, "Skipped the AndroidApplication overlay paths update - no app yet");
    } else {
        mAndroidApplication.overlayPaths = mPlatformPackageOverlayPaths;
        mAndroidApplication.resourceDirs = mPlatformPackageOverlayResourceDirs;
    }
    if (mResolverReplaced) {
        mResolveActivity.applicationInfo.overlayPaths = mReplacedResolverPackageOverlayPaths;
        mResolveActivity.applicationInfo.resourceDirs =
                mReplacedResolverPackageOverlayResourceDirs;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

@GuardedBy(anyOf = {"this", "mProcLock"})
private void updateApplicationInfoLOSP(@NonNull List<String> packagesToUpdate,
        boolean updateFrameworkRes, int userId) {
    if (updateFrameworkRes) {
        ParsingPackageUtils.readConfigUseRoundIcon(null);
    }

    mProcessList.updateApplicationInfoLOSP(packagesToUpdate, userId, updateFrameworkRes);

    if (updateFrameworkRes) {
        
        
        final Executor executor = ActivityThread.currentActivityThread().getExecutor();
        final DisplayManagerInternal display =
                LocalServices.getService(DisplayManagerInternal.class);
        if (display != null) {
            executor.execute(display::onOverlayChanged);
        }
        if (mWindowManager != null) {
            executor.execute(mWindowManager::onOverlayChanged);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

@GuardedBy(anyOf = {"mService", "mProcLock"})
void updateApplicationInfoLOSP(List<String> packagesToUpdate, int userId,
        boolean updateFrameworkRes) {
    final ArrayMap<String, ApplicationInfo> applicationInfoByPackage = new ArrayMap<>();
    for (int i = packagesToUpdate.size() - 1; i >= 0; i--) {
        final String packageName = packagesToUpdate.get(i);
        final ApplicationInfo ai = mService.getPackageManagerInternal().getApplicationInfo(
                packageName, STOCK_PM_FLAGS, Process.SYSTEM_UID, userId);
        if (ai != null) {
            applicationInfoByPackage.put(packageName, ai);
        }
    }
    mService.mActivityTaskManager.updateActivityApplicationInfo(userId,
            applicationInfoByPackage);

    final ArrayList<WindowProcessController> targetProcesses = new ArrayList<>();
    for (int i = mLruProcesses.size() - 1; i >= 0; i--) {
        final ProcessRecord app = mLruProcesses.get(i);
        if (app.getThread() == null) {
            continue;
        }

        if (userId != UserHandle.USER_ALL && app.userId != userId) {
            continue;
        }

        app.getPkgList().forEachPackage(packageName -> {
            if (updateFrameworkRes || packagesToUpdate.contains(packageName)) {
                try {
                    final ApplicationInfo ai = applicationInfoByPackage.get(packageName);
                    if (ai != null) {
                        if (ai.packageName.equals(app.info.packageName)) {
                            app.info = ai;
                            app.getWindowProcessController().updateApplicationInfo(ai);
                            PlatformCompatCache.getInstance()
                                    .onApplicationInfoChanged(ai);
                        }
                        app.getThread().scheduleApplicationInfoChanged(ai);
                        targetProcesses.add(app.getWindowProcessController());
                    }
                } catch (RemoteException e) {
                    Slog.w(TAG, String.format("Failed to update %s ApplicationInfo for %s",
                                packageName, app));
                }
            }
        });
    }

    mService.mActivityTaskManager.updateAssetConfiguration(targetProcesses, updateFrameworkRes);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

@VisibleForTesting(visibility = PACKAGE)
public void handleApplicationInfoChanged(@NonNull final ApplicationInfo ai) {
    
    
    
    
    
    LoadedApk apk;
    LoadedApk resApk;
    
    synchronized (mResourcesManager) {
        WeakReference<LoadedApk> ref = mPackages.get(ai.packageName);
        apk = ref != null ? ref.get() : null;
        ref = mResourcePackages.get(ai.packageName);
        resApk = ref != null ? ref.get() : null;
        for (ActivityClientRecord ar : mActivities.values()) {
            if (ar.activityInfo.applicationInfo.packageName.equals(ai.packageName)) {
                ar.activityInfo.applicationInfo = ai;
                if (apk != null || resApk != null) {
                    ar.packageInfo = apk != null ? apk : resApk;
                } else {
                    apk = ar.packageInfo;
                }
            }
        }
    }

    if (apk != null) {
        final ArrayList<String> oldPaths = new ArrayList<>();
        LoadedApk.makePaths(this, apk.getApplicationInfo(), oldPaths);
        apk.updateApplicationInfo(ai, oldPaths);
    }
    if (resApk != null) {
        final ArrayList<String> oldPaths = new ArrayList<>();
        LoadedApk.makePaths(this, resApk.getApplicationInfo(), oldPaths);
        resApk.updateApplicationInfo(ai, oldPaths);
    }
    if (android.content.res.Flags.systemContextHandleAppInfoChanged() && mSystemThread) {
        final var systemContext = getSystemContext();
        if (systemContext.getPackageName().equals(ai.packageName)) {
            
            
            final ArrayList<String> oldPaths = new ArrayList<>();
            LoadedApk.makePaths(this, systemContext.getApplicationInfo(), oldPaths);
            systemContext.mPackageInfo.updateApplicationInfo(ai, oldPaths);
        }
    }

    ResourcesImpl beforeImpl = getApplication().getResources().getImpl();

    synchronized (mResourcesManager) {
        
        mResourcesManager.applyAllPendingAppInfoUpdates();
    }

    ResourcesImpl afterImpl = getApplication().getResources().getImpl();

    if ((beforeImpl != afterImpl) && !Arrays.equals(beforeImpl.getAssets().getApkAssets(),
            afterImpl.getAssets().getApkAssets())) {
        List<String> beforeAssets = Arrays.asList(beforeImpl.getAssets().getApkPaths());
        List<String> afterAssets = Arrays.asList(afterImpl.getAssets().getApkPaths());

        List<String> onlyBefore = new ArrayList<>(beforeAssets);
        onlyBefore.removeAll(afterAssets);
        List<String> onlyAfter = new ArrayList<>(afterAssets);
        onlyAfter.removeAll(beforeAssets);

        Slog.i(TAG, "ApplicationInfo updating for " + ai.packageName + ", new timestamp: "
                + ai.createTimestamp + "\nassets removed: " + onlyBefore + "\nassets added: "
                + onlyAfter);

        if (DEBUG_APP_INFO) {
            Slog.v(TAG, "ApplicationInfo updating for " + ai.packageName
                    + ", assets before change: " + beforeAssets + "\n assets after change: "
                    + afterAssets);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

public void updateApplicationInfo(@NonNull ApplicationInfo aInfo,
        @Nullable List<String> oldPaths) {
    if (!setApplicationInfo(aInfo)) {
        return;
    }

    final List<String> newPaths = new ArrayList<>();
    makePaths(mActivityThread, aInfo, newPaths);
    final List<String> addedPaths = new ArrayList<>(newPaths.size());

    if (oldPaths != null) {
        for (String path : newPaths) {
            final String apkName = path.substring(path.lastIndexOf(File.separator));
            boolean match = false;
            for (String oldPath : oldPaths) {
                final String oldApkName = oldPath.substring(oldPath.lastIndexOf(File.separator));
                if (apkName.equals(oldApkName)) {
                    match = true;
                    break;
                }
            }
            if (!match) {
                addedPaths.add(path);
            }
        }
    } else {
        addedPaths.addAll(newPaths);
    }
    synchronized (mLock) {
        createOrUpdateClassLoaderLocked(addedPaths);
        if (mResources != null) {
            final String[] splitPaths;
            try {
                splitPaths = getSplitPaths(null);
            } catch (NameNotFoundException e) {
                
                throw new AssertionError("null split not found");
            }

            mResources = ResourcesManager.getInstance().getResources(null, mResDir,
                    splitPaths, mLegacyOverlayDirs, mOverlayPaths,
                    mApplicationInfo.sharedLibraryFiles, null, null, getCompatibilityInfo(),
                    getClassLoader(), mApplication == null ? null
                            : mApplication.getResources().getLoaders());
        }
    }
    mAppComponentFactory = createAppFactory(aInfo, mDefaultClassLoader);
}