Merge "Support CarrierService change callback in CarrierPrivilegesTracker" (89dabb58) · Commits · e / os / android_frameworks_opt_telephony

src/java/com/android/internal/telephony/CarrierPrivilegesTracker.java

+94 −27

Original line number	Diff line number	Diff line
		@@ -51,11 +51,13 @@ import android.os.Handler;
		import android.os.Looper;
		import android.os.Message;
		import android.os.PersistableBundle;
		import android.os.Process;
		import android.os.Registrant;
		import android.os.RegistrantList;
		import android.os.SystemClock;
		import android.os.UserHandle;
		import android.os.UserManager;
		import android.service.carrier.CarrierService;
		import android.telephony.Annotation.CarrierPrivilegeStatus;
		import android.telephony.CarrierConfigManager;
		import android.telephony.SubscriptionManager;
		@@ -67,12 +69,12 @@ import android.util.ArrayMap;
		import android.util.ArraySet;
		import android.util.IntArray;
		import android.util.LocalLog;
		import android.util.Pair;

		import com.android.internal.annotations.GuardedBy;
		import com.android.internal.telephony.uicc.IccUtils;
		import com.android.internal.telephony.uicc.UiccPort;
		import com.android.internal.telephony.uicc.UiccProfile;
		import com.android.internal.util.ArrayUtils;
		import com.android.telephony.Rlog;

		import java.io.FileDescriptor;
		@@ -83,6 +85,7 @@ import java.util.Collection;
		import java.util.Collections;
		import java.util.List;
		import java.util.Map;
		import java.util.Objects;
		import java.util.Set;
		import java.util.StringJoiner;
		import java.util.concurrent.TimeUnit;
		@@ -214,19 +217,21 @@ public class CarrierPrivilegesTracker extends Handler {
		/** Small snapshot to hold package names and UIDs of privileged packages. */
		private static final class PrivilegedPackageInfo {
		@NonNull final Set<String> mPackageNames;
		@NonNull final int[] mUids; // Note: must be kept sorted for equality purposes
		@NonNull final Set<Integer> mUids;
		// The carrier service (packageName, UID) pair
		@NonNull final Pair<String, Integer> mCarrierService;

		PrivilegedPackageInfo() {
		mPackageNames = Collections.emptySet();
		mUids = new int[0];
		mUids = Collections.emptySet();
		mCarrierService = new Pair<>(null, Process.INVALID_UID);
		}

		PrivilegedPackageInfo(@NonNull Set<String> packageNames, @NonNull Set<Integer> uids) {
		PrivilegedPackageInfo(@NonNull Set<String> packageNames, @NonNull Set<Integer> uids,
		@NonNull Pair<String, Integer> carrierService) {
		mPackageNames = packageNames;
		IntArray converter = new IntArray(uids.size());
		uids.forEach(converter::add);
		mUids = converter.toArray();
		Arrays.sort(mUids); // for equality purposes
		mUids = uids;
		mCarrierService = carrierService;
		}

		@Override
		@@ -234,7 +239,11 @@ public class CarrierPrivilegesTracker extends Handler {
		return "{packageNames="
		+ getObfuscatedPackages(mPackageNames, pkg -> Rlog.pii(TAG, pkg))
		+ ", uids="
		+ Arrays.toString(mUids)
		+ mUids
		+ ", carrierServicePackageName="
		+ Rlog.pii(TAG, mCarrierService.first)
		+ ", carrierServiceUid="
		+ mCarrierService.second
		+ "}";
		}

		@@ -247,13 +256,13 @@ public class CarrierPrivilegesTracker extends Handler {
		return false;
		}
		PrivilegedPackageInfo other = (PrivilegedPackageInfo) o;
		return mPackageNames.equals(other.mPackageNames) && Arrays.equals(mUids, other.mUids);
		return mPackageNames.equals(other.mPackageNames) && mUids.equals(other.mUids)
		&& mCarrierService.equals(other.mCarrierService);
		}

		@Override
		public int hashCode() {
		// Since we have an array, we have to use deepHashCode instead of "regular" Objects.hash
		return Arrays.deepHashCode(new Object[] {mPackageNames, mUids});
		return Objects.hash(mPackageNames, mUids, mCarrierService);
		}
		}

		@@ -404,9 +413,10 @@ public class CarrierPrivilegesTracker extends Handler {
		mRegistrantList.add(registrant);
		mPrivilegedPackageInfoLock.readLock().lock();
		try {
		// Old registrant callback still takes int[] as parameter, need conversion here
		int[] uids = intSetToArray(mPrivilegedPackageInfo.mUids);
		registrant.notifyResult(
		Arrays.copyOf(
		mPrivilegedPackageInfo.mUids, mPrivilegedPackageInfo.mUids.length));
		Arrays.copyOf(uids, uids.length));
		} finally {
		mPrivilegedPackageInfoLock.readLock().unlock();
		}
		@@ -639,9 +649,24 @@ public class CarrierPrivilegesTracker extends Handler {
		PrivilegedPackageInfo currentPrivilegedPackageInfo =
		getCurrentPrivilegedPackagesForAllUsers();

		boolean carrierPrivilegesPackageNamesChanged;
		boolean carrierPrivilegesUidsChanged;
		boolean carrierServiceChanged;

		mPrivilegedPackageInfoLock.readLock().lock();
		try {
		if (mPrivilegedPackageInfo.equals(currentPrivilegedPackageInfo)) return;

		mLocalLog.log("Privileged packages info changed. New state = "
		+ currentPrivilegedPackageInfo);

		carrierPrivilegesPackageNamesChanged =
		!currentPrivilegedPackageInfo.mPackageNames.equals(
		mPrivilegedPackageInfo.mPackageNames);
		carrierPrivilegesUidsChanged =
		!currentPrivilegedPackageInfo.mUids.equals(mPrivilegedPackageInfo.mUids);
		carrierServiceChanged = !currentPrivilegedPackageInfo.mCarrierService.equals(
		mPrivilegedPackageInfo.mCarrierService);
		} finally {
		mPrivilegedPackageInfoLock.readLock().unlock();
		}
		@@ -655,16 +680,24 @@ public class CarrierPrivilegesTracker extends Handler {

		mPrivilegedPackageInfoLock.readLock().lock();
		try {
		mLocalLog.log("Privileged packages changed. New state = " + mPrivilegedPackageInfo);
		mRegistrantList.notifyResult(
		Arrays.copyOf(
		mPrivilegedPackageInfo.mUids, mPrivilegedPackageInfo.mUids.length));
		// The obsoleted callback only care about UIDs
		if (carrierPrivilegesUidsChanged) {
		int[] uids = intSetToArray(mPrivilegedPackageInfo.mUids);
		mRegistrantList.notifyResult(Arrays.copyOf(uids, uids.length));
		}

		if (carrierPrivilegesPackageNamesChanged \|\| carrierPrivilegesUidsChanged) {
		mTelephonyRegistryManager.notifyCarrierPrivilegesChanged(
		mPhone.getPhoneId(),
		Collections.unmodifiableList(
		new ArrayList<>(mPrivilegedPackageInfo.mPackageNames)),
		Arrays.copyOf(
		mPrivilegedPackageInfo.mUids, mPrivilegedPackageInfo.mUids.length));
		Collections.unmodifiableSet(mPrivilegedPackageInfo.mPackageNames),
		Collections.unmodifiableSet(mPrivilegedPackageInfo.mUids));
		}

		if (carrierServiceChanged) {
		mTelephonyRegistryManager.notifyCarrierServiceChanged(mPhone.getPhoneId(),
		mPrivilegedPackageInfo.mCarrierService.first,
		mPrivilegedPackageInfo.mCarrierService.second);
		}
		} finally {
		mPrivilegedPackageInfoLock.readLock().unlock();
		}
		@@ -685,7 +718,8 @@ public class CarrierPrivilegesTracker extends Handler {
		privilegedUids.addAll(getUidsForPackage(e.getKey(), /* invalidateCache= */ false));
		}
		}
		return new PrivilegedPackageInfo(privilegedPackageNames, privilegedUids);
		return new PrivilegedPackageInfo(privilegedPackageNames, privilegedUids,
		getCarrierService(privilegedPackageNames));
		}

		/**
		@@ -744,6 +778,16 @@ public class CarrierPrivilegesTracker extends Handler {
		return uids;
		}

		private int getPackageUid(@Nullable String pkgName) {
		int uid = Process.INVALID_UID;
		try {
		uid = mPackageManager.getPackageUid(pkgName, /* flags= */0);
		} catch (NameNotFoundException e) {
		Rlog.e(TAG, "Unable to find uid for package " + pkgName);
		}
		return uid;
		}

		/**
		* Dump the local log buffer and other internal state of CarrierPrivilegesTracker.
		*/
		@@ -878,7 +922,7 @@ public class CarrierPrivilegesTracker extends Handler {
		try {
		if (mSimIsReadyButNotLoaded) {
		return CARRIER_PRIVILEGE_STATUS_RULES_NOT_LOADED;
		} else if (ArrayUtils.contains(mPrivilegedPackageInfo.mUids, uid)) {
		} else if (mPrivilegedPackageInfo.mUids.contains(uid)) {
		return CARRIER_PRIVILEGE_STATUS_HAS_ACCESS;
		} else {
		return CARRIER_PRIVILEGE_STATUS_NO_ACCESS;
		@@ -901,7 +945,6 @@ public class CarrierPrivilegesTracker extends Handler {
		mPrivilegedPackageInfoLock.readLock().unlock();
		}


		// Do the PackageManager queries before we take the lock, as these are the longest-running
		// pieces of this method and don't depend on the set of carrier apps.
		List<ResolveInfo> resolveInfos = new ArrayList<>();
		@@ -939,4 +982,28 @@ public class CarrierPrivilegesTracker extends Handler {
		if (resolveInfo.providerInfo != null) return resolveInfo.providerInfo.packageName;
		return null;
		}

		@NonNull
		private Pair<String, Integer> getCarrierService(@NonNull Set<String> privilegedPackageNames) {
		List<ResolveInfo> carrierServiceResolveInfos = mPackageManager.queryIntentServices(
		new Intent(CarrierService.CARRIER_SERVICE_INTERFACE), /* flags= */ 0);
		String carrierServicePackageName = null;
		for (ResolveInfo resolveInfo : carrierServiceResolveInfos) {
		String packageName = getPackageName(resolveInfo);
		if (privilegedPackageNames.contains(packageName)) {
		carrierServicePackageName = packageName;
		break;
		}
		}
		return carrierServicePackageName == null
		? new Pair<>(null, Process.INVALID_UID)
		: new Pair<>(carrierServicePackageName, getPackageUid(carrierServicePackageName));
		}

		@NonNull
		private static int[] intSetToArray(@NonNull Set<Integer> intSet) {
		IntArray converter = new IntArray(intSet.size());
		intSet.forEach(converter::add);
		return converter.toArray();
		}
		}

tests/telephonytests/src/com/android/internal/telephony/CarrierPrivilegesTrackerTest.java

+44 −45

Original line number	Diff line number	Diff line
		@@ -36,7 +36,6 @@ import static org.junit.Assert.assertEquals;
		import static org.junit.Assert.fail;
		import static org.mockito.Matchers.any;
		import static org.mockito.Matchers.anyInt;
		import static org.mockito.Matchers.argThat;
		import static org.mockito.Matchers.eq;
		import static org.mockito.Mockito.doReturn;
		import static org.mockito.Mockito.inOrder;
		@@ -121,6 +120,7 @@ public class CarrierPrivilegesTrackerTest extends TelephonyTest {
		private static final int UID_2 = 10000002;
		private static final int UID_3 = 10000003;
		private static final int[] PRIVILEGED_UIDS = {UID_1, UID_2};
		private static final Set<Integer> PRIVILEGED_UIDS_SET = Set.of(UID_1, UID_2);

		private static final int PM_FLAGS =
		PackageManager.GET_SIGNING_CERTIFICATES
		@@ -291,19 +291,18 @@ public class CarrierPrivilegesTrackerTest extends TelephonyTest {
		}

		private void verifyCarrierPrivilegesChangedUpdates(
		List<Pair<Set<String>, int[]>> expectedUpdates) {
		List<Pair<Set<String>, Set<Integer>>> expectedUpdates) {
		if (expectedUpdates.isEmpty()) {
		verify(mTelephonyRegistryManager, never())
		.notifyCarrierPrivilegesChanged(anyInt(), any(), any());
		} else {
		InOrder inOrder = inOrder(mTelephonyRegistryManager);
		for (Pair<Set<String>, int[]> expectedUpdate : expectedUpdates) {
		for (Pair<Set<String>, Set<Integer>> expectedUpdate : expectedUpdates) {
		// By looking at TelephonyRegistryManager, we can see the full flow as it evolves.
		inOrder.verify(mTelephonyRegistryManager)
		.notifyCarrierPrivilegesChanged(
		eq(PHONE_ID),
		// Callback gets a list, but we don't care about order so use Set
		argThat(list -> Set.copyOf(list).equals(expectedUpdate.first)),
		eq(expectedUpdate.first),
		eq(expectedUpdate.second));
		}
		}
		@@ -339,7 +338,7 @@ public class CarrierPrivilegesTrackerTest extends TelephonyTest {
		verifyCurrentState(PRIVILEGED_PACKAGES, PRIVILEGED_UIDS);
		verifyRegistrantUpdates(PRIVILEGED_UIDS /* expectedUids /, 1 / expectedUidUpdates */);
		verifyCarrierPrivilegesChangedUpdates(
		List.of(new Pair<>(PRIVILEGED_PACKAGES, PRIVILEGED_UIDS)));
		List.of(new Pair<>(PRIVILEGED_PACKAGES, PRIVILEGED_UIDS_SET)));
		mHandler.reset();
		reset(mTelephonyRegistryManager);

		@@ -356,7 +355,7 @@ public class CarrierPrivilegesTrackerTest extends TelephonyTest {

		verifyCurrentState(Set.of(), new int[0]);
		verifyRegistrantUpdates(null /* expectedUids /, 0 / expectedUidUpdates */);
		verifyCarrierPrivilegesChangedUpdates(List.of(new Pair<>(Set.of(), new int[0])));
		verifyCarrierPrivilegesChangedUpdates(List.of(new Pair<>(Set.of(), Set.of())));
		}

		@Test
		@@ -375,7 +374,7 @@ public class CarrierPrivilegesTrackerTest extends TelephonyTest {
		verifyCurrentState(PRIVILEGED_PACKAGES, PRIVILEGED_UIDS);
		verifyRegistrantUpdates(PRIVILEGED_UIDS, 1 /* expectedUidUpdates */);
		verifyCarrierPrivilegesChangedUpdates(
		List.of(new Pair<>(PRIVILEGED_PACKAGES, PRIVILEGED_UIDS)));
		List.of(new Pair<>(PRIVILEGED_PACKAGES, PRIVILEGED_UIDS_SET)));
		}

		@Test
		@@ -389,7 +388,7 @@ public class CarrierPrivilegesTrackerTest extends TelephonyTest {
		verifyCurrentState(PRIVILEGED_PACKAGES, PRIVILEGED_UIDS);
		verifyRegistrantUpdates(null /* expectedUids /, 0 / expectedUidUpdates */);
		verifyCarrierPrivilegesChangedUpdates(
		List.of(new Pair<>(PRIVILEGED_PACKAGES, PRIVILEGED_UIDS)));
		List.of(new Pair<>(PRIVILEGED_PACKAGES, PRIVILEGED_UIDS_SET)));
		}

		@Test
		@@ -404,8 +403,8 @@ public class CarrierPrivilegesTrackerTest extends TelephonyTest {
		verifyRegistrantUpdates(new int[0] /* expectedUids /, 1 / expectedUidUpdates */);
		verifyCarrierPrivilegesChangedUpdates(
		List.of(
		new Pair<>(PRIVILEGED_PACKAGES, PRIVILEGED_UIDS),
		new Pair<>(Set.of(), new int[0])));
		new Pair<>(PRIVILEGED_PACKAGES, PRIVILEGED_UIDS_SET),
		new Pair<>(Set.of(), Set.of())));
		}

		@Test
		@@ -421,7 +420,7 @@ public class CarrierPrivilegesTrackerTest extends TelephonyTest {

		verifyCurrentState(Set.of(), new int[0]);
		verifyRegistrantUpdates(new int[0] /* expectedUids /, 1 / expectedUidUpdates */);
		verifyCarrierPrivilegesChangedUpdates(List.of(new Pair<>(Set.of(), new int[0])));
		verifyCarrierPrivilegesChangedUpdates(List.of(new Pair<>(Set.of(), Set.of())));
		}

		@Test
		@@ -442,7 +441,7 @@ public class CarrierPrivilegesTrackerTest extends TelephonyTest {
		verifyCurrentState(Set.of(PACKAGE_1), new int[] {UID_1});
		verifyRegistrantUpdates(new int[] {UID_1}, 1 /* expectedUidUpdates */);
		verifyCarrierPrivilegesChangedUpdates(
		List.of(new Pair<>(Set.of(PACKAGE_1), new int[] {UID_1})));
		List.of(new Pair<>(Set.of(PACKAGE_1), Set.of(UID_1))));

		// Give package 2 privileges again.
		setupCarrierConfigRules(
		@@ -455,7 +454,7 @@ public class CarrierPrivilegesTrackerTest extends TelephonyTest {
		verifyCurrentState(PRIVILEGED_PACKAGES, PRIVILEGED_UIDS);
		verifyRegistrantUpdates(PRIVILEGED_UIDS, 2 /* expectedUidUpdates */);
		verifyCarrierPrivilegesChangedUpdates(
		List.of(new Pair<>(PRIVILEGED_PACKAGES, PRIVILEGED_UIDS)));
		List.of(new Pair<>(PRIVILEGED_PACKAGES, PRIVILEGED_UIDS_SET)));
		}

		@Test
		@@ -474,7 +473,7 @@ public class CarrierPrivilegesTrackerTest extends TelephonyTest {
		verifyCurrentState(PRIVILEGED_PACKAGES, PRIVILEGED_UIDS);
		verifyRegistrantUpdates(PRIVILEGED_UIDS, 1 /* expectedUidUpdates */);
		verifyCarrierPrivilegesChangedUpdates(
		List.of(new Pair<>(PRIVILEGED_PACKAGES, PRIVILEGED_UIDS)));
		List.of(new Pair<>(PRIVILEGED_PACKAGES, PRIVILEGED_UIDS_SET)));
		}

		@Test
		@@ -493,7 +492,7 @@ public class CarrierPrivilegesTrackerTest extends TelephonyTest {
		verifyCurrentState(PRIVILEGED_PACKAGES, PRIVILEGED_UIDS);
		verifyRegistrantUpdates(PRIVILEGED_UIDS, 1 /* expectedUidUpdates */);
		verifyCarrierPrivilegesChangedUpdates(
		List.of(new Pair<>(PRIVILEGED_PACKAGES, PRIVILEGED_UIDS)));
		List.of(new Pair<>(PRIVILEGED_PACKAGES, PRIVILEGED_UIDS_SET)));
		}

		@Test
		@@ -510,8 +509,8 @@ public class CarrierPrivilegesTrackerTest extends TelephonyTest {
		verifyRegistrantUpdates(new int[0], 1 /* expectedUidUpdates */);
		verifyCarrierPrivilegesChangedUpdates(
		List.of(
		new Pair<>(PRIVILEGED_PACKAGES, PRIVILEGED_UIDS),
		new Pair<>(Set.of(), new int[0])));
		new Pair<>(PRIVILEGED_PACKAGES, PRIVILEGED_UIDS_SET),
		new Pair<>(Set.of(), Set.of())));
		}

		@Test
		@@ -527,7 +526,7 @@ public class CarrierPrivilegesTrackerTest extends TelephonyTest {
		verifyCurrentState(PRIVILEGED_PACKAGES, PRIVILEGED_UIDS);
		verifyRegistrantUpdates(null /* expectedUids /, 0 / expectedUidUpdates */);
		verifyCarrierPrivilegesChangedUpdates(
		List.of(new Pair<>(PRIVILEGED_PACKAGES, PRIVILEGED_UIDS)));
		List.of(new Pair<>(PRIVILEGED_PACKAGES, PRIVILEGED_UIDS_SET)));
		}

		@Test
		@@ -542,7 +541,7 @@ public class CarrierPrivilegesTrackerTest extends TelephonyTest {
		verifyCurrentState(Set.of(PACKAGE_1, PACKAGE_2), new int[]{UID_1, UID_2});

		// Wait for 30 seconds
		Thread.sleep(TimeUnit.SECONDS.toMillis(30));
		moveTimeForward(TimeUnit.SECONDS.toMillis(30));
		mTestableLooper.processAllMessages();

		// Check again, the carrier privileges should be emptied
		@@ -550,8 +549,8 @@ public class CarrierPrivilegesTrackerTest extends TelephonyTest {
		verifyRegistrantUpdates(new int[0], 1 /* expectedUidUpdates */);
		verifyCarrierPrivilegesChangedUpdates(
		List.of(
		new Pair<>(PRIVILEGED_PACKAGES, PRIVILEGED_UIDS),
		new Pair<>(Set.of(), new int[0])));
		new Pair<>(PRIVILEGED_PACKAGES, PRIVILEGED_UIDS_SET),
		new Pair<>(Set.of(), Set.of())));
		}

		@Test
		@@ -567,11 +566,11 @@ public class CarrierPrivilegesTrackerTest extends TelephonyTest {


		// Wait for 20 seconds and the same SIM is inserted
		Thread.sleep(TimeUnit.SECONDS.toMillis(20));
		moveTimeForward(TimeUnit.SECONDS.toMillis(20));
		sendSimCardStateChangedIntent(PHONE_ID, SIM_STATE_LOADED);
		mTestableLooper.processAllMessages();
		// Wait for another 20 seconds
		Thread.sleep(TimeUnit.SECONDS.toMillis(20));
		moveTimeForward(TimeUnit.SECONDS.toMillis(20));

		// verify all carrier privileges should remain, no CP change notified
		verifyCurrentState(Set.of(PACKAGE_1, PACKAGE_2), new int[]{UID_1, UID_2});
		@@ -591,14 +590,14 @@ public class CarrierPrivilegesTrackerTest extends TelephonyTest {
		mTestableLooper.processAllMessages();

		// Wait for 30 seconds
		Thread.sleep(TimeUnit.SECONDS.toMillis(30));
		moveTimeForward(TimeUnit.SECONDS.toMillis(30));
		mTestableLooper.processAllMessages();

		// verify the carrier privileges should be emptied
		verifyCurrentState(Set.of(), new int[0]);
		verifyRegistrantUpdates(new int[0], 1 /* expectedUidUpdates */);
		verifyCarrierPrivilegesChangedUpdates(
		List.of(new Pair<>(Set.of(), new int[0])));
		List.of(new Pair<>(Set.of(), Set.of())));
		}

		@Test
		@@ -613,14 +612,14 @@ public class CarrierPrivilegesTrackerTest extends TelephonyTest {
		mTestableLooper.processAllMessages();

		// Wait for 30 seconds
		Thread.sleep(TimeUnit.SECONDS.toMillis(30));
		moveTimeForward(TimeUnit.SECONDS.toMillis(30));
		mTestableLooper.processAllMessages();

		// verify the carrier privileges should be emptied
		verifyCurrentState(Set.of(), new int[0]);
		verifyRegistrantUpdates(new int[0], 1 /* expectedUidUpdates */);
		verifyCarrierPrivilegesChangedUpdates(
		List.of(new Pair<>(Set.of(), new int[0])));
		List.of(new Pair<>(Set.of(), Set.of())));
		}

		@Test
		@@ -635,18 +634,18 @@ public class CarrierPrivilegesTrackerTest extends TelephonyTest {


		// Wait for 20 seconds and a different SIM is inserted
		Thread.sleep(TimeUnit.SECONDS.toMillis(20));
		moveTimeForward(TimeUnit.SECONDS.toMillis(20));
		setupSimLoadedRules(ruleWithHashOnly(getHash(CERT_1)));
		sendSimCardStateChangedIntent(PHONE_ID, SIM_STATE_LOADED);
		mTestableLooper.processAllMessages();
		// Wait for another 20 seconds
		Thread.sleep(TimeUnit.SECONDS.toMillis(20));
		moveTimeForward(TimeUnit.SECONDS.toMillis(20));

		// Carrier privileges should be updated and CP change should be notified
		verifyCurrentState(Set.of(PACKAGE_1), new int[] {UID_1});
		verifyRegistrantUpdates(new int[] {UID_1}, 1 /* expectedUidUpdates */);
		verifyCarrierPrivilegesChangedUpdates(
		List.of(new Pair<>(Set.of(PACKAGE_1), new int[] {UID_1})));
		List.of(new Pair<>(Set.of(PACKAGE_1), Set.of(UID_1))));
		}

		@Test
		@@ -706,7 +705,7 @@ public class CarrierPrivilegesTrackerTest extends TelephonyTest {
		verifyCurrentState(Set.of(PACKAGE_1), new int[] {UID_1});
		verifyRegistrantUpdates(new int[] {UID_1}, 1 /* expectedUidUpdates */);
		verifyCarrierPrivilegesChangedUpdates(
		List.of(new Pair<>(Set.of(PACKAGE_1), new int[] {UID_1})));
		List.of(new Pair<>(Set.of(PACKAGE_1), Set.of(UID_1))));

		// Give package 2 privileges again.
		setupSimLoadedRules(
		@@ -720,7 +719,7 @@ public class CarrierPrivilegesTrackerTest extends TelephonyTest {
		verifyCurrentState(PRIVILEGED_PACKAGES, PRIVILEGED_UIDS);
		verifyRegistrantUpdates(PRIVILEGED_UIDS, 2 /* expectedUidUpdates */);
		verifyCarrierPrivilegesChangedUpdates(
		List.of(new Pair<>(PRIVILEGED_PACKAGES, PRIVILEGED_UIDS)));
		List.of(new Pair<>(PRIVILEGED_PACKAGES, PRIVILEGED_UIDS_SET)));
		}

		@Test
		@@ -737,7 +736,7 @@ public class CarrierPrivilegesTrackerTest extends TelephonyTest {
		verifyCurrentState(Set.of(PACKAGE_1), new int[] {UID_1});
		verifyRegistrantUpdates(new int[] {UID_1}, 1 /* expectedUidUpdates */);
		verifyCarrierPrivilegesChangedUpdates(
		List.of(new Pair<>(Set.of(PACKAGE_1), new int[] {UID_1})));
		List.of(new Pair<>(Set.of(PACKAGE_1), Set.of(UID_1))));
		}

		@Test
		@@ -757,7 +756,7 @@ public class CarrierPrivilegesTrackerTest extends TelephonyTest {
		verifyCurrentState(Set.of(PACKAGE_1), PRIVILEGED_UIDS);
		verifyRegistrantUpdates(PRIVILEGED_UIDS, 1 /* expectedUidUpdates */);
		verifyCarrierPrivilegesChangedUpdates(
		List.of(new Pair<>(Set.of(PACKAGE_1), PRIVILEGED_UIDS)));
		List.of(new Pair<>(Set.of(PACKAGE_1), PRIVILEGED_UIDS_SET)));
		}

		@Test
		@@ -778,7 +777,7 @@ public class CarrierPrivilegesTrackerTest extends TelephonyTest {
		verifyCurrentState(Set.of(PACKAGE_1), PRIVILEGED_UIDS);
		verifyRegistrantUpdates(PRIVILEGED_UIDS, 1 /* expectedUidUpdates */);
		verifyCarrierPrivilegesChangedUpdates(
		List.of(new Pair<>(Set.of(PACKAGE_1), PRIVILEGED_UIDS)));
		List.of(new Pair<>(Set.of(PACKAGE_1), PRIVILEGED_UIDS_SET)));
		}

		@Test
		@@ -803,7 +802,7 @@ public class CarrierPrivilegesTrackerTest extends TelephonyTest {
		verifyCurrentState(Set.of(PACKAGE_2), new int[] {UID_2});
		verifyRegistrantUpdates(new int[] {UID_2}, 1 /* expectedUidUpdates */);
		verifyCarrierPrivilegesChangedUpdates(
		List.of(new Pair<>(Set.of(PACKAGE_2), new int[] {UID_2})));
		List.of(new Pair<>(Set.of(PACKAGE_2), Set.of(UID_2))));
		}

		@Test
		@@ -827,7 +826,7 @@ public class CarrierPrivilegesTrackerTest extends TelephonyTest {
		verifyCurrentState(Set.of(PACKAGE_2), new int[] {UID_2});
		verifyRegistrantUpdates(new int[] {UID_2}, 1 /* expectedUidUpdates */);
		verifyCarrierPrivilegesChangedUpdates(
		List.of(new Pair<>(Set.of(PACKAGE_2), new int[] {UID_2})));
		List.of(new Pair<>(Set.of(PACKAGE_2), Set.of(UID_2))));
		}

		@Test
		@@ -846,7 +845,7 @@ public class CarrierPrivilegesTrackerTest extends TelephonyTest {
		verifyCurrentState(Set.of(PACKAGE_2), new int[] {UID_2});
		verifyRegistrantUpdates(new int[] {UID_2}, 1 /* expectedUidUpdates */);
		verifyCarrierPrivilegesChangedUpdates(
		List.of(new Pair<>(Set.of(PACKAGE_2), new int[] {UID_2})));
		List.of(new Pair<>(Set.of(PACKAGE_2), Set.of(UID_2))));
		}

		@Test
		@@ -877,8 +876,8 @@ public class CarrierPrivilegesTrackerTest extends TelephonyTest {
		verifyRegistrantUpdates(new int[0], 1 /* expectedUidUpdates */);
		verifyCarrierPrivilegesChangedUpdates(
		List.of(
		new Pair<>(PRIVILEGED_PACKAGES, PRIVILEGED_UIDS),
		new Pair<>(Set.of(), new int[0])));
		new Pair<>(PRIVILEGED_PACKAGES, PRIVILEGED_UIDS_SET),
		new Pair<>(Set.of(), Set.of())));

		// Set test override with null rule to revoke previous test override
		mCarrierPrivilegesTracker.setTestOverrideCarrierPrivilegeRules(null);
		@@ -888,7 +887,7 @@ public class CarrierPrivilegesTrackerTest extends TelephonyTest {
		verifyCurrentState(PRIVILEGED_PACKAGES, PRIVILEGED_UIDS);
		verifyRegistrantUpdates(PRIVILEGED_UIDS, 2 /* expectedUidUpdates */);
		verifyCarrierPrivilegesChangedUpdates(
		List.of(new Pair<>(PRIVILEGED_PACKAGES, PRIVILEGED_UIDS)));
		List.of(new Pair<>(PRIVILEGED_PACKAGES, PRIVILEGED_UIDS_SET)));
		}

		@Test
		@@ -905,8 +904,8 @@ public class CarrierPrivilegesTrackerTest extends TelephonyTest {
		verifyRegistrantUpdates(new int[]{UID_3}, 1 /* expectedUidUpdates */);
		verifyCarrierPrivilegesChangedUpdates(
		List.of(
		new Pair<>(PRIVILEGED_PACKAGES, PRIVILEGED_UIDS),
		new Pair<>(Set.of(PACKAGE_3), new int[]{UID_3})));
		new Pair<>(PRIVILEGED_PACKAGES, PRIVILEGED_UIDS_SET),
		new Pair<>(Set.of(PACKAGE_3), Set.of(UID_3))));


		// Set test override with null rule to revoke previous test override
		@@ -917,7 +916,7 @@ public class CarrierPrivilegesTrackerTest extends TelephonyTest {
		verifyCurrentState(PRIVILEGED_PACKAGES, PRIVILEGED_UIDS);
		verifyRegistrantUpdates(PRIVILEGED_UIDS, 2 /* expectedUidUpdates */);
		verifyCarrierPrivilegesChangedUpdates(
		List.of(new Pair<>(PRIVILEGED_PACKAGES, PRIVILEGED_UIDS)));
		List.of(new Pair<>(PRIVILEGED_PACKAGES, PRIVILEGED_UIDS_SET)));
		}

		@Test