Merge "Invalidate cached result of getPackagesForUid" into sc-dev

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

@@ -588,29 +588,32 @@ public class AppsFilter implements Watchable, Snappable {
      *
      * @param recipientUid the uid gaining visibility of the {@code visibleUid}.
      * @param visibleUid   the uid becoming visible to the {@recipientUid}
+     * @return {@code true} if implicit access was not already granted.
      */
-    public void grantImplicitAccess(int recipientUid, int visibleUid) {
+    public boolean grantImplicitAccess(int recipientUid, int visibleUid) {
-        if (recipientUid != visibleUid) {
+        if (recipientUid == visibleUid) {
-            final boolean changed = mImplicitlyQueryable.add(recipientUid, visibleUid);
+            return false;
-            if (changed && DEBUG_LOGGING) {
+        }
-                Slog.i(TAG, "implicit access granted: " + recipientUid + " -> " + visibleUid);
+        final boolean changed = mImplicitlyQueryable.add(recipientUid, visibleUid);
-            }
+        if (changed && DEBUG_LOGGING) {
-            synchronized (mCacheLock) {
+            Slog.i(TAG, "implicit access granted: " + recipientUid + " -> " + visibleUid);
-                if (mShouldFilterCache != null) {
+        }
-                    // update the cache in a one-off manner since we've got all the information we
+        synchronized (mCacheLock) {
-                    // need.
+            if (mShouldFilterCache != null) {
-                    SparseBooleanArray visibleUids = mShouldFilterCache.get(recipientUid);
+                // update the cache in a one-off manner since we've got all the information we
-                    if (visibleUids == null) {
+                // need.
-                        visibleUids = new SparseBooleanArray();
+                SparseBooleanArray visibleUids = mShouldFilterCache.get(recipientUid);
-                        mShouldFilterCache.put(recipientUid, visibleUids);
+                if (visibleUids == null) {
-                    }
+                    visibleUids = new SparseBooleanArray();
-                    visibleUids.put(visibleUid, false);
+                    mShouldFilterCache.put(recipientUid, visibleUids);
                 }
-            }
+                visibleUids.put(visibleUid, false);
-            if (changed) {
-                onChanged();
             }
         }
+        if (changed) {
+            onChanged();
+        }
+        return changed;
     }
 
     public void onSystemReady() {

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

@@ -470,23 +470,34 @@ class InstantAppRegistry implements Watchable, Snappable {
         return instantGrantList.get(instantAppId);
     }
 
+    /**
+     * Allows an app to see an instant app.
+     *
+     * @param userId the userId in which this access is being granted
+     * @param intent when provided, this serves as the intent that caused
+     *               this access to be granted
+     * @param recipientUid the uid of the app receiving visibility
+     * @param instantAppId the app ID of the instant app being made visible
+     *                      to the recipient
+     * @return {@code true} if access is granted.
+     */
     @GuardedBy("mService.mLock")
-    public void grantInstantAccessLPw(@UserIdInt int userId, @Nullable Intent intent,
+    public boolean grantInstantAccessLPw(@UserIdInt int userId, @Nullable Intent intent,
             int recipientUid, int instantAppId) {
         if (mInstalledInstantAppUids == null) {
-            return;     // no instant apps installed; no need to grant
+            return false;     // no instant apps installed; no need to grant
         }
         WatchedSparseBooleanArray instantAppList = mInstalledInstantAppUids.get(userId);
         if (instantAppList == null || !instantAppList.get(instantAppId)) {
-            return;     // instant app id isn't installed; no need to grant
+            return false;     // instant app id isn't installed; no need to grant
         }
         if (instantAppList.get(recipientUid)) {
-            return;     // target app id is an instant app; no need to grant
+            return false;     // target app id is an instant app; no need to grant
         }
         if (intent != null && Intent.ACTION_VIEW.equals(intent.getAction())) {
             final Set<String> categories = intent.getCategories();
             if (categories != null && categories.contains(Intent.CATEGORY_BROWSABLE)) {
-                return;  // launched via VIEW/BROWSABLE intent; no need to grant
+                return false;  // launched via VIEW/BROWSABLE intent; no need to grant
             }
         }
         WatchedSparseArray<WatchedSparseBooleanArray> targetAppList = mInstantGrants.get(userId);
@@ -500,6 +511,7 @@ class InstantAppRegistry implements Watchable, Snappable {
             targetAppList.put(recipientUid, instantGrantList);
         }
         instantGrantList.put(instantAppId, true /*granted*/);
+        return true;
     }
 
     @GuardedBy("mService.mLock")

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

@@ -27188,6 +27188,7 @@ public class PackageManagerService extends IPackageManager.Stub
 
                 final boolean instantApp =
                         isInstantAppInternal(visiblePackage.getPackageName(), userId, visibleUid);
+                final boolean accessGranted;
                 if (instantApp) {
                     if (!direct) {
                         // if the interaction that lead to this granting access to an instant app
@@ -27195,10 +27196,13 @@ public class PackageManagerService extends IPackageManager.Stub
                         // grant.
                         return;
                     }
-                    mInstantAppRegistry.grantInstantAccessLPw(userId, intent,
+                    accessGranted = mInstantAppRegistry.grantInstantAccessLPw(userId, intent,
                             recipientAppId, UserHandle.getAppId(visibleUid) /*instantAppId*/);
                 } else {
-                    mAppsFilter.grantImplicitAccess(recipientUid, visibleUid);
+                    accessGranted = mAppsFilter.grantImplicitAccess(recipientUid, visibleUid);
+                }
+                if (accessGranted) {
+                    ApplicationPackageManager.invalidateGetPackagesForUidCache();
                 }
             }
         }