Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 5990b7f6 authored by Songchun Fan's avatar Songchun Fan
Browse files

[AppsFilter] use snapshots instead of live data 

Remove all runWithStates that use the live data and use snapshots
instead. This ensures that if AppsFilter is called by a snapshot, it
uses the data from the same snapshot. Also prevent corner-case lock
contentions where a snapshot calls to acquire mPm.mLock.

BUG: 226668722
Test: unit test
Test: manual check of boot time
Change-Id: I2b8472659392b9e7c499bb816dd23e9470655af4
Merged-In: I2b8472659392b9e7c499bb816dd23e9470655af4
parent f38c1aa1

services/core/java/com/android/server/pm/AppsFilterImpl.java

+207 −247
Original line number Diff line number Diff line
@@ -61,6 +61,7 @@ import com.android.server.pm.pkg.component.ParsedInstrumentation; 
import com.android.server.pm.pkg.component.ParsedIntentInfo;

import com.android.server.pm.pkg.component.ParsedMainComponent;

import com.android.server.pm.pkg.component.ParsedProvider;

import com.android.server.pm.snapshot.PackageDataSnapshot;

import com.android.server.utils.Snappable;

import com.android.server.utils.SnapshotCache;

import com.android.server.utils.Watchable;
@@ -179,7 +180,6 @@ public class AppsFilterImpl implements AppsFilterSnapshot, Watchable, Snappable 
    private final boolean mSystemAppsQueryable;

    private final FeatureConfig mFeatureConfig;

    private final OverlayReferenceMapper mOverlayReferenceMapper;

    private final StateProvider mStateProvider;

    private SigningDetails mSystemSigningDetails;



    @GuardedBy("mLock")
@@ -192,7 +192,8 @@ public class AppsFilterImpl implements AppsFilterSnapshot, Watchable, Snappable 
    /**

     * This structure maps uid -> uid and indicates whether access from the first should be

     * filtered to the second. It's essentially a cache of the

     * {@link #shouldFilterApplicationInternal(int, Object, PackageStateInternal, int)} call.

     * {@link #shouldFilterApplicationInternal(PackageDataSnapshot, int, Object,

     * PackageStateInternal, int)} call.

     * NOTE: It can only be relied upon after the system is ready to avoid unnecessary update on

     * initial scam and is empty until {@link #mSystemReady} is true.

     */
@@ -282,8 +283,7 @@ public class AppsFilterImpl implements AppsFilterSnapshot, Watchable, Snappable 
    }



    @VisibleForTesting(visibility = PRIVATE)

    AppsFilterImpl(StateProvider stateProvider,

            FeatureConfig featureConfig,

    AppsFilterImpl(FeatureConfig featureConfig,

            String[] forceQueryableList,

            boolean systemAppsQueryable,

            @Nullable OverlayReferenceMapper.Provider overlayProvider,
@@ -293,7 +293,6 @@ public class AppsFilterImpl implements AppsFilterSnapshot, Watchable, Snappable 
        mSystemAppsQueryable = systemAppsQueryable;

        mOverlayReferenceMapper = new OverlayReferenceMapper(true /*deferRebuild*/,

                overlayProvider);

        mStateProvider = stateProvider;

        mBackgroundExecutor = backgroundExecutor;

        mShouldFilterCache = new WatchedSparseBooleanMatrix();

        mShouldFilterCacheSnapshot = new SnapshotCache.Auto<>(
@@ -352,7 +351,6 @@ public class AppsFilterImpl implements AppsFilterSnapshot, Watchable, Snappable 
        mSystemAppsQueryable = orig.mSystemAppsQueryable;

        mFeatureConfig = orig.mFeatureConfig;

        mOverlayReferenceMapper = orig.mOverlayReferenceMapper;

        mStateProvider = orig.mStateProvider;

        mSystemSigningDetails = orig.mSystemSigningDetails;

        synchronized (orig.mCacheLock) {

            mShouldFilterCache = orig.mShouldFilterCacheSnapshot.snapshot();
@@ -361,7 +359,7 @@ public class AppsFilterImpl implements AppsFilterSnapshot, Watchable, Snappable 


        mBackgroundExecutor = null;

        mSnapshot = new SnapshotCache.Sealed<>();

        mSystemReady = true;

        mSystemReady = orig.mSystemReady;

    }



    /**
@@ -373,23 +371,6 @@ public class AppsFilterImpl implements AppsFilterSnapshot, Watchable, Snappable 
        return mSnapshot.snapshot();

    }



    /**

     * Provides system state to AppsFilter via {@link CurrentStateCallback} after properly guarding

     * the data with the package lock.

     *

     * Don't call {@link #runWithState} with {@link #mCacheLock} held.

     */

    @VisibleForTesting(visibility = PRIVATE)

    public interface StateProvider {

        void runWithState(CurrentStateCallback callback);



        interface CurrentStateCallback {

            void currentState(ArrayMap<String, ? extends PackageStateInternal> settings,

                    Collection<SharedUserSetting> sharedUserSettings,

                    UserInfo[] users);

        }

    }



    @VisibleForTesting(visibility = PRIVATE)

    public interface FeatureConfig {
@@ -517,12 +498,13 @@ public class AppsFilterImpl implements AppsFilterSnapshot, Watchable, Snappable 


        @Override

        public void onCompatChange(String packageName) {

            AndroidPackage pkg = mPmInternal.getPackage(packageName);

            PackageDataSnapshot snapshot = mPmInternal.snapshot();

            AndroidPackage pkg = snapshot.getPackage(packageName);

            if (pkg == null) {

                return;

            }

            updateEnabledState(pkg);

            mAppsFilter.updateShouldFilterCacheForPackage(packageName);

            mAppsFilter.updateShouldFilterCacheForPackage(snapshot, packageName);

        }



        private void updateEnabledState(@NonNull AndroidPackage pkg) {
@@ -574,14 +556,7 @@ public class AppsFilterImpl implements AppsFilterSnapshot, Watchable, Snappable 
                forcedQueryablePackageNames[i] = forcedQueryablePackageNames[i].intern();

            }

        }

        final StateProvider stateProvider = command -> {

            synchronized (injector.getLock()) {

                command.currentState(injector.getSettings().getPackagesLocked().untrackedStorage(),

                        injector.getSettings().getAllSharedUsersLPw(),

                        injector.getUserManagerInternal().getUserInfos());

            }

        };

        AppsFilterImpl appsFilter = new AppsFilterImpl(stateProvider, featureConfig,

        AppsFilterImpl appsFilter = new AppsFilterImpl(featureConfig,

                forcedQueryablePackageNames, forceSystemAppsQueryable, null,

                injector.getBackgroundExecutor());

        featureConfig.setAppsFilter(appsFilter);
@@ -754,12 +729,11 @@ public class AppsFilterImpl implements AppsFilterSnapshot, Watchable, Snappable 
        return changed;

    }



    public void onSystemReady() {

    public void onSystemReady(PackageManagerInternal pmInternal) {

        mOverlayReferenceMapper.rebuildIfDeferred();

        mFeatureConfig.onSystemReady();



        updateEntireShouldFilterCacheAsync();

        onChanged();

        updateEntireShouldFilterCacheAsync(pmInternal);

        mSystemReady = true;

    }
@@ -769,39 +743,41 @@ public class AppsFilterImpl implements AppsFilterSnapshot, Watchable, Snappable 
     * @param newPkgSetting the new setting being added

     * @param isReplace     if the package is being replaced and may need extra cleanup.

     */

    public void addPackage(PackageStateInternal newPkgSetting, boolean isReplace) {

    public void addPackage(PackageDataSnapshot snapshot, PackageStateInternal newPkgSetting,

            boolean isReplace) {

        if (DEBUG_TRACING) {

            Trace.traceBegin(TRACE_TAG_PACKAGE_MANAGER, "filter.addPackage");

        }

        try {

            if (isReplace) {

                // let's first remove any prior rules for this package

                removePackage(newPkgSetting, true /*isReplace*/);

                removePackage(snapshot, newPkgSetting, true /*isReplace*/);

            }

            mStateProvider.runWithState((settings, sharedUserSettings, users) -> {

                ArraySet<String> additionalChangedPackages =

            final ArrayMap<String, ? extends PackageStateInternal> settings =

                    snapshot.getPackageStates();

            final UserInfo[] users = snapshot.getUserInfos();

            final ArraySet<String> additionalChangedPackages =

                    addPackageInternal(newPkgSetting, settings);

            if (mSystemReady) {

                    updateShouldFilterCacheForPackage(null, newPkgSetting,

                synchronized (mCacheLock) {

                    updateShouldFilterCacheForPackage(snapshot, null, newPkgSetting,

                            settings, users, USER_ALL, settings.size());

                    if (additionalChangedPackages != null) {

                        for (int index = 0; index < additionalChangedPackages.size(); index++) {

                            String changedPackage = additionalChangedPackages.valueAt(index);

                            PackageStateInternal changedPkgSetting =

                                    settings.get(changedPackage);

                            PackageStateInternal changedPkgSetting = settings.get(changedPackage);

                            if (changedPkgSetting == null) {

                                // It's possible for the overlay mapper to know that an actor

                                // package changed via an explicit reference, even if the actor

                                // isn't installed, so skip if that's the case.

                                continue;

                            }



                            updateShouldFilterCacheForPackage(null, changedPkgSetting,

                            updateShouldFilterCacheForPackage(snapshot, null, changedPkgSetting,

                                    settings, users, USER_ALL, settings.size());

                        }

                    }

                }

            } // else, rebuild entire cache when system is ready

            });

        } finally {

            onChanged();

            if (DEBUG_TRACING) {
@@ -941,12 +917,14 @@ public class AppsFilterImpl implements AppsFilterSnapshot, Watchable, Snappable 
        }

    }



    private void updateEntireShouldFilterCache() {

        updateEntireShouldFilterCache(USER_ALL);

    private void updateEntireShouldFilterCache(PackageDataSnapshot snapshot) {

        updateEntireShouldFilterCache(snapshot, USER_ALL);

    }



    private void updateEntireShouldFilterCache(int subjectUserId) {

        mStateProvider.runWithState((settings, sharedUserSettings, users) -> {

    private void updateEntireShouldFilterCache(PackageDataSnapshot snapshot, int subjectUserId) {

        final ArrayMap<String, ? extends PackageStateInternal> settings =

                snapshot.getPackageStates();

        final UserInfo[] users = snapshot.getUserInfos();

        int userId = USER_NULL;

        for (int u = 0; u < users.length; u++) {

            if (subjectUserId == users[u].id) {
@@ -959,12 +937,12 @@ public class AppsFilterImpl implements AppsFilterSnapshot, Watchable, Snappable 
                    + "updating the whole cache");

            userId = USER_ALL;

        }

            updateEntireShouldFilterCacheInner(settings, users, userId);

        });

        updateEntireShouldFilterCacheInner(snapshot, settings, users, userId);



        onChanged();

    }



    private void updateEntireShouldFilterCacheInner(

    private void updateEntireShouldFilterCacheInner(PackageDataSnapshot snapshot,

            ArrayMap<String, ? extends PackageStateInternal> settings,

            UserInfo[] users,

            int subjectUserId) {
@@ -973,23 +951,24 @@ public class AppsFilterImpl implements AppsFilterSnapshot, Watchable, Snappable 
                mShouldFilterCache.clear();

            }

            mShouldFilterCache.setCapacity(users.length * settings.size());

        }

            for (int i = settings.size() - 1; i >= 0; i--) {

            updateShouldFilterCacheForPackage(

                updateShouldFilterCacheForPackage(snapshot,

                        null /*skipPackage*/, settings.valueAt(i), settings, users,

                        subjectUserId, i);

            }

        }

    }



    private void updateEntireShouldFilterCacheAsync() {

    private void updateEntireShouldFilterCacheAsync(PackageManagerInternal pmInternal) {

        mBackgroundExecutor.execute(() -> {

            final ArrayMap<String, PackageStateInternal> settingsCopy = new ArrayMap<>();

            final Collection<SharedUserSetting> sharedUserSettingsCopy = new ArraySet<>();

            final ArrayMap<String, AndroidPackage> packagesCache = new ArrayMap<>();

            final UserInfo[][] usersRef = new UserInfo[1][];

            mStateProvider.runWithState((settings, sharedUserSettings, users) -> {

            final PackageDataSnapshot snapshot = pmInternal.snapshot();

            final ArrayMap<String, ? extends PackageStateInternal> settings =

                    snapshot.getPackageStates();

            final UserInfo[] users = snapshot.getUserInfos();



            packagesCache.ensureCapacity(settings.size());

                settingsCopy.putAll(settings);

            usersRef[0] = users;

            // store away the references to the immutable packages, since settings are retained

            // during updates.
@@ -997,43 +976,17 @@ public class AppsFilterImpl implements AppsFilterSnapshot, Watchable, Snappable 
                final AndroidPackage pkg = settings.valueAt(i).getPkg();

                packagesCache.put(settings.keyAt(i), pkg);

            }

                sharedUserSettingsCopy.addAll(sharedUserSettings);

            });



            boolean[] changed = new boolean[1];

            // We have a cache, let's make sure the world hasn't changed out from under us.

            mStateProvider.runWithState((settings, sharedUserSettings, users) -> {

                if (settings.size() != settingsCopy.size()) {

                    changed[0] = true;

                    return;

                }

                for (int i = 0, max = settings.size(); i < max; i++) {

                    final AndroidPackage pkg = settings.valueAt(i).getPkg();

                    if (!Objects.equals(pkg, packagesCache.get(settings.keyAt(i)))) {

                        changed[0] = true;

                        return;

                    }

                }

            });

            if (changed[0]) {

                // Something has changed, just update the cache inline with the lock held

                updateEntireShouldFilterCache();

                if (DEBUG_LOGGING) {

                    Slog.i(TAG, "Rebuilding cache with lock due to package change.");

                }

            } else {

                updateEntireShouldFilterCacheInner(settingsCopy,

                        usersRef[0], USER_ALL);

            updateEntireShouldFilterCacheInner(snapshot, settings, usersRef[0], USER_ALL);

            onChanged();

            }

        });

    }



    public void onUserCreated(int newUserId) {

    public void onUserCreated(PackageDataSnapshot snapshot, int newUserId) {

        if (!mSystemReady) {

            return;

        }

        updateEntireShouldFilterCache(newUserId);

        updateEntireShouldFilterCache(snapshot, newUserId);

    }



    public void onUserDeleted(@UserIdInt int userId) {
@@ -1044,19 +997,24 @@ public class AppsFilterImpl implements AppsFilterSnapshot, Watchable, Snappable 
        onChanged();

    }



    private void updateShouldFilterCacheForPackage(String packageName) {

        mStateProvider.runWithState((settings, sharedUserSettings, users) -> {

    private void updateShouldFilterCacheForPackage(PackageDataSnapshot snapshot,

            String packageName) {

        if (!mSystemReady) {

            return;

        }

            updateShouldFilterCacheForPackage(null /* skipPackage */,

        final ArrayMap<String, ? extends PackageStateInternal> settings =

                snapshot.getPackageStates();

        final UserInfo[] users = snapshot.getUserInfos();

        synchronized (mCacheLock) {

            updateShouldFilterCacheForPackage(snapshot, null /* skipPackage */,

                    settings.get(packageName), settings, users, USER_ALL,

                    settings.size() /*maxIndex*/);

        });

        }

        onChanged();

    }



    private void updateShouldFilterCacheForPackage(

    @GuardedBy("mCacheLock")

    private void updateShouldFilterCacheForPackage(PackageDataSnapshot snapshot,

            @Nullable String skipPackageName, PackageStateInternal subjectSetting, ArrayMap<String,

            ? extends PackageStateInternal> allSettings, UserInfo[] allUsers, int subjectUserId,

            int maxIndex) {
@@ -1072,33 +1030,32 @@ public class AppsFilterImpl implements AppsFilterSnapshot, Watchable, Snappable 
            }

            if (subjectUserId == USER_ALL) {

                for (int su = 0; su < allUsers.length; su++) {

                    updateShouldFilterCacheForUser(subjectSetting, allUsers, otherSetting,

                    updateShouldFilterCacheForUser(snapshot, subjectSetting, allUsers, otherSetting,

                            allUsers[su].id);

                }

            } else {

                updateShouldFilterCacheForUser(subjectSetting, allUsers, otherSetting,

                updateShouldFilterCacheForUser(snapshot, subjectSetting, allUsers, otherSetting,

                        subjectUserId);

            }

        }

    }



    private void updateShouldFilterCacheForUser(

    @GuardedBy("mCacheLock")

    private void updateShouldFilterCacheForUser(PackageDataSnapshot snapshot,

            PackageStateInternal subjectSetting, UserInfo[] allUsers,

            PackageStateInternal otherSetting, int subjectUserId) {

        for (int ou = 0; ou < allUsers.length; ou++) {

            int otherUser = allUsers[ou].id;

            int subjectUid = UserHandle.getUid(subjectUserId, subjectSetting.getAppId());

            int otherUid = UserHandle.getUid(otherUser, otherSetting.getAppId());

            final boolean shouldFilterSubjectToOther = shouldFilterApplicationInternal(

            final boolean shouldFilterSubjectToOther = shouldFilterApplicationInternal(snapshot,

                    subjectUid, subjectSetting, otherSetting, otherUser);

            final boolean shouldFilterOtherToSubject = shouldFilterApplicationInternal(

            final boolean shouldFilterOtherToSubject = shouldFilterApplicationInternal(snapshot,

                    otherUid, otherSetting, subjectSetting, subjectUserId);

            synchronized (mCacheLock) {

            mShouldFilterCache.put(subjectUid, otherUid, shouldFilterSubjectToOther);

            mShouldFilterCache.put(otherUid, subjectUid, shouldFilterOtherToSubject);

        }

    }

    }



    private void removeShouldFilterCacheForUser(int userId) {

        synchronized (mCacheLock) {
@@ -1182,11 +1139,13 @@ public class AppsFilterImpl implements AppsFilterSnapshot, Watchable, Snappable 
    }



    /**

     * See {@link AppsFilterSnapshot#getVisibilityAllowList(PackageStateInternal, int[], ArrayMap)}

     * See {@link AppsFilterSnapshot#getVisibilityAllowList(PackageDataSnapshot,

     * PackageStateInternal, int[], ArrayMap)}

     */

    @Override

    @Nullable

    public SparseArray<int[]> getVisibilityAllowList(PackageStateInternal setting, int[] users,

    public SparseArray<int[]> getVisibilityAllowList(PackageDataSnapshot snapshot,

            PackageStateInternal setting, int[] users,

            ArrayMap<String, ? extends PackageStateInternal> existingSettings) {

        synchronized (mLock) {

            if (mForceQueryable.contains(setting.getAppId())) {
@@ -1211,7 +1170,8 @@ public class AppsFilterImpl implements AppsFilterSnapshot, Watchable, Snappable 
                    continue;

                }

                final int existingUid = UserHandle.getUid(userId, existingAppId);

                if (!shouldFilterApplication(existingUid, existingSetting, setting, userId)) {

                if (!shouldFilterApplication(snapshot, existingUid, existingSetting, setting,

                        userId)) {

                    if (buffer == null) {

                        buffer = new int[appIds.length];

                    }
@@ -1232,19 +1192,21 @@ public class AppsFilterImpl implements AppsFilterSnapshot, Watchable, Snappable 
     */

    @VisibleForTesting(visibility = PRIVATE)

    @Nullable

    SparseArray<int[]> getVisibilityAllowList(PackageStateInternal setting, int[] users,

    SparseArray<int[]> getVisibilityAllowList(PackageDataSnapshot snapshot,

            PackageStateInternal setting, int[] users,

            WatchedArrayMap<String, ? extends PackageStateInternal> existingSettings) {

        return getVisibilityAllowList(setting, users, existingSettings.untrackedStorage());

        return getVisibilityAllowList(snapshot, setting, users,

                existingSettings.untrackedStorage());

    }



    /**

     * Equivalent to calling {@link #addPackage(PackageStateInternal, boolean)} with

     * {@code isReplace} equal to {@code false}.

     * Equivalent to calling {@link #addPackage(PackageDataSnapshot, PackageStateInternal, boolean)}

     * with {@code isReplace} equal to {@code false}.

     *

     * @see AppsFilterImpl#addPackage(PackageStateInternal, boolean)

     * @see AppsFilterImpl#addPackage(PackageDataSnapshot, PackageStateInternal, boolean)

     */

    public void addPackage(PackageStateInternal newPkgSetting) {

        addPackage(newPkgSetting, false /* isReplace */);

    public void addPackage(PackageDataSnapshot snapshot, PackageStateInternal newPkgSetting) {

        addPackage(snapshot, newPkgSetting, false /* isReplace */);

    }



    /**
@@ -1253,9 +1215,13 @@ public class AppsFilterImpl implements AppsFilterSnapshot, Watchable, Snappable 
     * @param setting   the setting of the package being removed.

     * @param isReplace if the package is being replaced.

     */

    public void removePackage(PackageStateInternal setting, boolean isReplace) {

        mStateProvider.runWithState((settings, sharedUserSettings, users) -> {

    public void removePackage(PackageDataSnapshot snapshot, PackageStateInternal setting,

            boolean isReplace) {

        final ArraySet<String> additionalChangedPackages;

        final ArrayMap<String, ? extends PackageStateInternal> settings =

                snapshot.getPackageStates();

        final UserInfo[] users = snapshot.getUserInfos();

        final Collection<SharedUserSetting> sharedUserSettings = snapshot.getAllSharedUsers();

        final int userCount = users.length;

        synchronized (mLock) {

            for (int u = 0; u < userCount; u++) {
@@ -1313,12 +1279,9 @@ public class AppsFilterImpl implements AppsFilterSnapshot, Watchable, Snappable 
        additionalChangedPackages = mOverlayReferenceMapper.removePkg(setting.getPackageName());

        mFeatureConfig.updatePackageState(setting, true /*removed*/);



            // After removing all traces of the package, if it's part of a shared user,

            // re-add other

            // shared user members to re-establish visibility between them and other

            // packages.

            // NOTE: this must come after all removals from data structures but before we

            // update the

        // After removing all traces of the package, if it's part of a shared user, re-add other

        // shared user members to re-establish visibility between them and other packages.

        // NOTE: this must come after all removals from data structures but before we update the

        // cache

        if (setting.hasSharedUser()) {

            final ArraySet<? extends PackageStateInternal> sharedUserPackages =
@@ -1342,11 +1305,13 @@ public class AppsFilterImpl implements AppsFilterSnapshot, Watchable, Snappable 
                if (siblingSetting == setting) {

                    continue;

                }

                    updateShouldFilterCacheForPackage(

                synchronized (mCacheLock) {

                    updateShouldFilterCacheForPackage(snapshot,

                            setting.getPackageName(), siblingSetting, settings,

                            users, USER_ALL, settings.size());

                }

            }

        }



        if (mSystemReady) {

            if (additionalChangedPackages != null) {
@@ -1359,13 +1324,13 @@ public class AppsFilterImpl implements AppsFilterSnapshot, Watchable, Snappable 
                        // isn't installed, so skip if that's the case.

                        continue;

                    }



                        updateShouldFilterCacheForPackage(null, changedPkgSetting,

                    synchronized (mCacheLock) {

                        updateShouldFilterCacheForPackage(snapshot, null, changedPkgSetting,

                                settings, users, USER_ALL, settings.size());

                    }

                }

            }

        });

        }

        onChanged();

    }
@@ -1382,12 +1347,12 @@ public class AppsFilterImpl implements AppsFilterSnapshot, Watchable, Snappable 


    /**

     * See

     * {@link AppsFilterSnapshot#shouldFilterApplication(int, Object, PackageStateInternal,

     * int)}

     * {@link AppsFilterSnapshot#shouldFilterApplication(PackageDataSnapshot, int, Object,

     * PackageStateInternal, int)}

     */

    @Override

    public boolean shouldFilterApplication(int callingUid, @Nullable Object callingSetting,

            PackageStateInternal targetPkgSetting, int userId) {

    public boolean shouldFilterApplication(PackageDataSnapshot snapshot, int callingUid,

            @Nullable Object callingSetting, PackageStateInternal targetPkgSetting, int userId) {

        if (DEBUG_TRACING) {

            Trace.traceBegin(TRACE_TAG_PACKAGE_MANAGER, "shouldFilterApplication");

        }
@@ -1405,7 +1370,7 @@ public class AppsFilterImpl implements AppsFilterSnapshot, Watchable, Snappable 
                    return false;

                }

            } else {

                if (!shouldFilterApplicationInternal(

                if (!shouldFilterApplicationInternal(snapshot,

                        callingUid, callingSetting, targetPkgSetting, userId)) {

                    return false;

                }
@@ -1440,8 +1405,8 @@ public class AppsFilterImpl implements AppsFilterSnapshot, Watchable, Snappable 
        }

    }



    private boolean shouldFilterApplicationInternal(int callingUid, Object callingSetting,

            PackageStateInternal targetPkgSetting, int targetUserId) {

    private boolean shouldFilterApplicationInternal(PackageDataSnapshot snapshot, int callingUid,

            Object callingSetting, PackageStateInternal targetPkgSetting, int targetUserId) {

        if (DEBUG_TRACING) {

            Trace.traceBegin(TRACE_TAG_PACKAGE_MANAGER, "shouldFilterApplicationInternal");

        }
@@ -1467,9 +1432,8 @@ public class AppsFilterImpl implements AppsFilterSnapshot, Watchable, Snappable 
                final PackageStateInternal packageState = (PackageStateInternal) callingSetting;

                if (packageState.hasSharedUser()) {

                    callingPkgSetting = null;

                    mStateProvider.runWithState((settings, sharedUserSettings, users) ->

                    callingSharedPkgSettings.addAll(getSharedUserPackages(

                                    packageState.getSharedUserAppId(), sharedUserSettings)));

                            packageState.getSharedUserAppId(), snapshot.getAllSharedUsers()));



                } else {

                    callingPkgSetting = packageState;
@@ -1600,11 +1564,7 @@ public class AppsFilterImpl implements AppsFilterSnapshot, Watchable, Snappable 
                    Trace.traceBegin(TRACE_TAG_PACKAGE_MANAGER, "mQueriesViaComponent");

                }

                if (mQueriesViaComponentRequireRecompute) {

                    final ArrayMap<String, PackageStateInternal> settingsCopy = new ArrayMap<>();

                    mStateProvider.runWithState((settings, sharedUserSettings, users) -> {

                        settingsCopy.putAll(settings);

                    });

                    recomputeComponentVisibility(settingsCopy);

                    recomputeComponentVisibility(snapshot.getPackageStates());

                    onChanged();

                }

                synchronized (mLock) {

services/core/java/com/android/server/pm/AppsFilterSnapshot.java

+7 −3

File changed.

Preview size limit exceeded, changes collapsed.

services/core/java/com/android/server/pm/Computer.java

+11 −0

File changed.

Preview size limit exceeded, changes collapsed.

services/core/java/com/android/server/pm/ComputerEngine.java

+17 −5

File changed.

Preview size limit exceeded, changes collapsed.

services/core/java/com/android/server/pm/DeletePackageHelper.java

+3 −2
Original line number Diff line number Diff line
@@ -543,8 +543,9 @@ final class DeletePackageHelper { 
        synchronized (mPm.mLock) {

            if (outInfo != null) {

                outInfo.mUid = ps.getAppId();

                outInfo.mBroadcastAllowList = mPm.mAppsFilter.getVisibilityAllowList(ps,

                        allUserHandles, mPm.mSettings.getPackagesLocked());

                outInfo.mBroadcastAllowList = mPm.mAppsFilter.getVisibilityAllowList(

                        mPm.snapshotComputer(), ps, allUserHandles,

                        mPm.mSettings.getPackagesLocked());

            }

        }