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

Commit 9ea5fabc authored by Rambo Wang's avatar Rambo Wang
Browse files

Support CarrierService change callback in CarrierPrivilegesTracker 

CarrierPrivilegesListener has re-shaped to support CarrierService
change and updated the carrier privileges change callback.

This CL update CarrierPrivilegesTracker to implement the new interface.

Bug: 216549778
Test: atest CarrierPrivilegesTrackerTest
Change-Id: Id7cc95200468b1913cbcf2f0053bc1963f2c66b0
parent aeb0ee3e

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

+92 −27
Original line number Diff line number Diff line
@@ -69,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;
@@ -85,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;
@@ -216,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
@@ -236,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

                    + "}";

        }
@@ -249,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);

        }

    }
@@ -406,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();

        }
@@ -641,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();

        }
@@ -657,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();

        }
@@ -687,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));

    }



    /**
@@ -746,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.

     */
@@ -880,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;
@@ -922,7 +964,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<>();
@@ -960,4 +1001,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
@@ -294,19 +294,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));

            }

        }
@@ -342,7 +341,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);
@@ -359,7 +358,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
@@ -378,7 +377,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
@@ -392,7 +391,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
@@ -407,8 +406,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
@@ -424,7 +423,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
@@ -445,7 +444,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(
@@ -458,7 +457,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
@@ -477,7 +476,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
@@ -496,7 +495,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
@@ -513,8 +512,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
@@ -530,7 +529,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
@@ -545,7 +544,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
@@ -553,8 +552,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
@@ -570,11 +569,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});
@@ -594,14 +593,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
@@ -616,14 +615,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
@@ -638,18 +637,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
@@ -709,7 +708,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(
@@ -723,7 +722,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
@@ -740,7 +739,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
@@ -760,7 +759,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
@@ -781,7 +780,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
@@ -806,7 +805,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
@@ -830,7 +829,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
@@ -849,7 +848,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
@@ -880,8 +879,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);
@@ -891,7 +890,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
@@ -908,8 +907,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
@@ -920,7 +919,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