Merge "Test new callback for permission change events" into main

1 files changed, 105 insertions, 51 deletions

diff --git a/tests/cts/permission/src/android/permission/cts/PermissionUpdateListenerTest.java b/tests/cts/permission/src/android/permission/cts/PermissionUpdateListenerTest.java
index 5eee04e61..e87dde97b 100644
--- a/tests/cts/permission/src/android/permission/cts/PermissionUpdateListenerTest.java
+++ b/tests/cts/permission/src/android/permission/cts/PermissionUpdateListenerTest.java
@@ -22,20 +22,22 @@ import static com.android.compatibility.common.util.SystemUtil.runWithShellPermi
 
 import static com.google.common.truth.Truth.assertThat;
 
+import android.companion.virtual.VirtualDeviceManager;
 import android.content.Context;
 import android.content.pm.PackageManager;
 import android.content.pm.PackageManager.OnPermissionsChangedListener;
 import android.platform.test.annotations.AppModeFull;
 
-import androidx.annotation.NonNull;
 import androidx.test.internal.runner.junit4.AndroidJUnit4ClassRunner;
 import androidx.test.platform.app.InstrumentationRegistry;
 
-import org.junit.AfterClass;
-import org.junit.BeforeClass;
+import org.junit.After;
+import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
 
@@ -50,80 +52,132 @@ public class PermissionUpdateListenerTest {
     private static final String PERMISSION_NAME = "android.permission.READ_CONTACTS";
     private static final int TIMEOUT = 30000;
 
-    private static final Context sContext =
+    private final Context mContext =
             InstrumentationRegistry.getInstrumentation().getContext();
-    private static final PackageManager sPm = sContext.getPackageManager();
-    private static int sUid;
+    private final PackageManager mPackageManager = mContext.getPackageManager();
 
-    @BeforeClass
-    public static void installApp() throws PackageManager.NameNotFoundException {
+    private int mTestAppUid;
+
+    @Before
+    public void setup() throws PackageManager.NameNotFoundException {
         runShellCommandOrThrow("pm install -r " + APK);
-        sUid = sPm.getPackageUid(PACKAGE_NAME, 0);
+        mTestAppUid = mPackageManager.getPackageUid(PACKAGE_NAME, 0);
     }
 
-    @AfterClass
-    public static void unInstallApp() {
+    @After
+    public void cleanup() {
         runShellCommand("pm uninstall " + PACKAGE_NAME);
     }
 
-    private class LatchWithPermissionsChangedListener extends CountDownLatch
-            implements OnPermissionsChangedListener {
-
-        LatchWithPermissionsChangedListener() {
-            super(1);
-        }
+    @Test
+    public void testGrantPermissionInvokesOldCallback() throws InterruptedException {
+        final CountDownLatch countDownLatch = new CountDownLatch(1);
+        OnPermissionsChangedListener permissionsChangedListener =
+                uid -> {
+                    if (mTestAppUid == uid) {
+                        countDownLatch.countDown();
+                    }
+                };
 
-        public void onPermissionsChanged(int uid) {
-            if (uid == sUid) {
-                countDown();
-            }
-        }
-    }
+        runWithShellPermissionIdentity(() -> {
+            mPackageManager.addOnPermissionsChangeListener(permissionsChangedListener);
+            mPackageManager.grantRuntimePermission(PACKAGE_NAME, PERMISSION_NAME,
+                    mContext.getUser());
+        });
+        countDownLatch.await(TIMEOUT, TimeUnit.MILLISECONDS);
+        runWithShellPermissionIdentity(() -> {
+            mPackageManager.removeOnPermissionsChangeListener(permissionsChangedListener);
+        });
 
-    private void waitForLatchAndRemoveListener(@NonNull LatchWithPermissionsChangedListener latch)
-            throws Exception {
-        latch.await(TIMEOUT, TimeUnit.MILLISECONDS);
-        runWithShellPermissionIdentity(() -> sPm.removeOnPermissionsChangeListener(latch));
-        assertThat(latch.getCount()).isEqualTo((long) 0);
+        assertThat(countDownLatch.getCount()).isEqualTo(0);
     }
 
     @Test
-    public void grantNotifiesListener() throws Exception {
-        LatchWithPermissionsChangedListener listenerCalled =
-                new LatchWithPermissionsChangedListener();
+    public void testGrantPermissionNotifyListener() throws InterruptedException {
+        TestOnPermissionsChangedListener permissionsChangedListener =
+                new TestOnPermissionsChangedListener(1);
+        runWithShellPermissionIdentity(() -> {
+            mPackageManager.addOnPermissionsChangeListener(permissionsChangedListener);
+            mPackageManager.grantRuntimePermission(PACKAGE_NAME, PERMISSION_NAME,
+                    mContext.getUser());
+        });
 
+        permissionsChangedListener.waitForPermissionChangedCallbacks();
         runWithShellPermissionIdentity(() -> {
-            sPm.revokeRuntimePermission(PACKAGE_NAME, PERMISSION_NAME, sContext.getUser());
-            sPm.addOnPermissionsChangeListener(listenerCalled);
-            sPm.grantRuntimePermission(PACKAGE_NAME, PERMISSION_NAME, sContext.getUser());
+            mPackageManager.removeOnPermissionsChangeListener(permissionsChangedListener);
         });
-        waitForLatchAndRemoveListener(listenerCalled);
+
+        String deviceId = permissionsChangedListener.getNotifiedDeviceId(mTestAppUid);
+        assertThat(deviceId).isEqualTo(VirtualDeviceManager.PERSISTENT_DEVICE_ID_DEFAULT);
     }
 
     @Test
-    public void revokeNotifiesListener() throws Exception {
-        LatchWithPermissionsChangedListener listenerCalled =
-                new LatchWithPermissionsChangedListener();
-
+    public void testRevokePermissionNotifyListener() throws InterruptedException {
+        TestOnPermissionsChangedListener permissionsChangedListener =
+                new TestOnPermissionsChangedListener(1);
         runWithShellPermissionIdentity(() -> {
-            sPm.grantRuntimePermission(PACKAGE_NAME, PERMISSION_NAME, sContext.getUser());
-            sPm.addOnPermissionsChangeListener(listenerCalled);
-            sPm.revokeRuntimePermission(PACKAGE_NAME, PERMISSION_NAME, sContext.getUser());
+            mPackageManager.addOnPermissionsChangeListener(permissionsChangedListener);
+            mPackageManager.revokeRuntimePermission(PACKAGE_NAME, PERMISSION_NAME,
+                    mContext.getUser());
         });
-        waitForLatchAndRemoveListener(listenerCalled);
+        permissionsChangedListener.waitForPermissionChangedCallbacks();
+        runWithShellPermissionIdentity(() -> {
+            mPackageManager.removeOnPermissionsChangeListener(permissionsChangedListener);
+        });
+
+        String deviceId = permissionsChangedListener.getNotifiedDeviceId(mTestAppUid);
+        assertThat(deviceId).isEqualTo(VirtualDeviceManager.PERSISTENT_DEVICE_ID_DEFAULT);
     }
 
     @Test
-    public void updateFlagsNotifiesListener() throws Exception {
-        LatchWithPermissionsChangedListener listenerCalled =
-                new LatchWithPermissionsChangedListener();
-
+    public void testUpdatePermissionFlagsNotifyListener() throws InterruptedException {
+        TestOnPermissionsChangedListener permissionsChangedListener =
+                new TestOnPermissionsChangedListener(1);
         runWithShellPermissionIdentity(() -> {
-            sPm.addOnPermissionsChangeListener(listenerCalled);
+            mPackageManager.addOnPermissionsChangeListener(permissionsChangedListener);
             int flag = PackageManager.FLAG_PERMISSION_USER_SET;
-            sPm.updatePermissionFlags(PERMISSION_NAME, PACKAGE_NAME, flag, flag,
-                    sContext.getUser());
+            mPackageManager.updatePermissionFlags(PERMISSION_NAME, PACKAGE_NAME, flag, flag,
+                    mContext.getUser());
+        });
+        permissionsChangedListener.waitForPermissionChangedCallbacks();
+        runWithShellPermissionIdentity(() -> {
+            mPackageManager.removeOnPermissionsChangeListener(permissionsChangedListener);
         });
-        waitForLatchAndRemoveListener(listenerCalled);
+
+        String deviceId = permissionsChangedListener.getNotifiedDeviceId(mTestAppUid);
+        assertThat(deviceId).isEqualTo(VirtualDeviceManager.PERSISTENT_DEVICE_ID_DEFAULT);
+    }
+
+    private class TestOnPermissionsChangedListener
+            implements OnPermissionsChangedListener {
+        // map of uid and persistentDeviceID
+        private final Map<Integer, String> mUidDeviceIdsMap = new ConcurrentHashMap<>();
+        private final CountDownLatch mCountDownLatch;
+
+        TestOnPermissionsChangedListener(int expectedCallbackCount) {
+            mCountDownLatch = new CountDownLatch(expectedCallbackCount);
+        }
+
+        @Override
+        public void onPermissionsChanged(int uid) {
+            // ignored when we implement the new callback.
+        }
+
+        @Override
+        public void onPermissionsChanged(int uid, String deviceId) {
+            if (uid == mTestAppUid) {
+                mCountDownLatch.countDown();
+                mUidDeviceIdsMap.put(uid, deviceId);
+            }
+        }
+
+        String getNotifiedDeviceId(int uid) {
+            return mUidDeviceIdsMap.get(uid);
+        }
+
+        void waitForPermissionChangedCallbacks() throws InterruptedException {
+            mCountDownLatch.await(TIMEOUT, TimeUnit.MILLISECONDS);
+            assertThat(mCountDownLatch.getCount()).isEqualTo(0);
+        }
     }
 }