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

Commit a0c38a4b authored by Rhed Jao's avatar Rhed Jao
Browse files

Applies package visibility for the broadcast of suspended packages 

To allows building the allow list before sending, this cl breaks
the original broadcast up from

[{
  action: ACTION_PACKAGES_SUSPENDED,
  extras: {EXTRA_SUSPENDED_PACKAGES: [com.app.a, com.app.b],
           EXTRA_SUSPENDED_UIDS: [10342, 10358]}
}]

into the following two:

[{
  action: ACTION_PACKAGES_SUSPENDED,
  extras: {EXTRA_SUSPENDED_PACKAGES: [com.app.a],
           EXTRA_SUSPENDED_UIDS: [10342]}
},
{
  action: ACTION_PACKAGES_SUSPENDED,
  extras: {EXTRA_SUSPENDED_PACKAGES: [com.app.b],
	   EXTRA_SUSPENDED_UIDS: [10358]}
}]

It also compares allow lists and merges the broadcast if allow
lists are the same.

Bug: 166181423
Test: atest AppEnumerationTests
Test: atest SuspendPackagesTest
Test: atest SuspendPackagesBroadcastTest
Change-Id: Ie3bb0f18d2b1b933a9a422d0850863b88179076b
parent 30664e5e

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

+48 −9
Original line number Diff line number Diff line
@@ -15454,16 +15454,55 @@ public class PackageManagerService extends IPackageManager.Stub 
                null);

    }













    private void sendPackagesSuspendedForUser(String[] pkgList, int[] uidList, int userId,













    @VisibleForTesting(visibility = Visibility.PRIVATE)













    void sendPackagesSuspendedForUser(String[] pkgList, int[] uidList, int userId,















            boolean suspended) {













        final List<List<String>> pkgsToSend = new ArrayList(pkgList.length);













        final List<IntArray> uidsToSend = new ArrayList(pkgList.length);













        final List<SparseArray<int[]>> allowListsToSend = new ArrayList(pkgList.length);













        final int[] userIds = new int[] {userId};













        // Get allow lists for the pkg in the pkgList. Merge into the existed pkgs and uids if













        // allow lists are the same.













        synchronized (mLock) {













            for (int i = 0; i < pkgList.length; i++) {













                final String pkgName = pkgList[i];













                final int uid = uidList[i];













                SparseArray<int[]> allowList = mAppsFilter.getVisibilityAllowList(













                        getPackageSettingInternal(pkgName, Process.SYSTEM_UID),













                        userIds, mSettings.getPackagesLocked());













                if (allowList == null) {













                    allowList = new SparseArray<>(0);













                }













                boolean merged = false;













                for (int j = 0; j < allowListsToSend.size(); j++) {













                    if (Arrays.equals(allowListsToSend.get(j).get(userId), allowList.get(userId))) {













                        pkgsToSend.get(j).add(pkgName);













                        uidsToSend.get(j).add(uid);













                        merged = true;













                        break;













                    }













                }













                if (!merged) {













                    pkgsToSend.add(new ArrayList<>(Arrays.asList(pkgName)));













                    uidsToSend.add(IntArray.wrap(new int[] {uid}));













                    allowListsToSend.add(allowList);













                }













            }













        }

























        for (int i = 0; i < pkgsToSend.size(); i++) {















            final Bundle extras = new Bundle(3);













        extras.putStringArray(Intent.EXTRA_CHANGED_PACKAGE_LIST, pkgList);













        extras.putIntArray(Intent.EXTRA_CHANGED_UID_LIST, uidList);













            extras.putStringArray(Intent.EXTRA_CHANGED_PACKAGE_LIST,













                    pkgsToSend.get(i).toArray(new String[pkgsToSend.get(i).size()]));













            extras.putIntArray(Intent.EXTRA_CHANGED_UID_LIST, uidsToSend.get(i).toArray());













            final SparseArray<int[]> allowList = allowListsToSend.get(i).size() == 0













                    ? null : allowListsToSend.get(i);















            sendPackageBroadcast(















                    suspended ? Intent.ACTION_PACKAGES_SUSPENDED















                            : Intent.ACTION_PACKAGES_UNSUSPENDED,















                    null, extras, Intent.FLAG_RECEIVER_REGISTERED_ONLY, null, null,













                new int[] {userId}, null, null, null);













                    userIds, null, allowList, null);













        }















    }





























    /**

























services/tests/mockingservicestests/src/com/android/server/pm/SuspendPackagesBroadcastTest.kt
0 → 100644



+163
−0




























Original line number
Diff line number
Diff line













/*













 * Copyright (C) 2021 The Android Open Source Project













 *













 * Licensed under the Apache License, Version 2.0 (the "License");













 * you may not use this file except in compliance with the License.













 * You may obtain a copy of the License at













 *













 *      http://www.apache.org/licenses/LICENSE-2.0













 *













 * Unless required by applicable law or agreed to in writing, software













 * distributed under the License is distributed on an "AS IS" BASIS,













 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.













 * See the License for the specific language governing permissions and













 * limitations under the License.













 */



























package com.android.server.pm



























import android.content.Intent













import android.os.Build













import android.os.Bundle













import android.util.SparseArray













import com.android.server.testutils.any













import com.android.server.testutils.eq













import com.android.server.testutils.nullable













import com.android.server.testutils.whenever













import com.android.server.utils.WatchedArrayMap













import com.google.common.truth.Truth.assertThat













import org.junit.Before













import org.junit.Rule













import org.junit.Test













import org.junit.runner.RunWith













import org.junit.runners.JUnit4













import org.mockito.ArgumentCaptor













import org.mockito.ArgumentMatchers.anyInt













import org.mockito.Captor













import org.mockito.Mockito.spy













import org.mockito.Mockito.times













import org.mockito.Mockito.verify













import org.mockito.MockitoAnnotations



























@RunWith(JUnit4::class)













class SuspendPackagesBroadcastTest {



























    companion object {













        const val TEST_PACKAGE_1 = "com.android.test.package1"













        const val TEST_PACKAGE_2 = "com.android.test.package2"













        const val TEST_USER_ID = 0













    }



























    lateinit var pms: PackageManagerService













    lateinit var packageSetting1: PackageSetting













    lateinit var packageSetting2: PackageSetting













    lateinit var packagesToSuspend: Array<String>













    lateinit var uidsToSuspend: IntArray



























    @Captor













    lateinit var bundleCaptor: ArgumentCaptor<Bundle>



























    @Rule













    @JvmField













    val rule = MockSystemRule()



























    @Before













    @Throws(Exception::class)













    fun setup() {













        MockitoAnnotations.initMocks(this)













        rule.system().stageNominalSystemState()













        pms = spy(createPackageManagerService(TEST_PACKAGE_1, TEST_PACKAGE_2))













        packageSetting1 = pms.getPackageSetting(TEST_PACKAGE_1)!!













        packageSetting2 = pms.getPackageSetting(TEST_PACKAGE_2)!!













        packagesToSuspend = arrayOf(TEST_PACKAGE_1, TEST_PACKAGE_2)













        uidsToSuspend = intArrayOf(packageSetting1.appId, packageSetting2.appId)













    }



























    @Test













    @Throws(Exception::class)













    fun sendPackagesSuspendedForUser_withSameVisibilityAllowList() {













        mockAllowList(packageSetting1, allowList(10001, 10002, 10003))













        mockAllowList(packageSetting2, allowList(10001, 10002, 10003))



























        pms.sendPackagesSuspendedForUser(













                packagesToSuspend, uidsToSuspend, TEST_USER_ID, /* suspended = */ true)













        verify(pms).sendPackageBroadcast(any(), nullable(), bundleCaptor.capture(),













                anyInt(), nullable(), nullable(), any(), nullable(), any(), nullable())



























        var changedPackages = bundleCaptor.value.getStringArray(Intent.EXTRA_CHANGED_PACKAGE_LIST)













        var changedUids = bundleCaptor.value.getIntArray(Intent.EXTRA_CHANGED_UID_LIST)













        assertThat(changedPackages).asList().containsExactly(TEST_PACKAGE_1, TEST_PACKAGE_2)













        assertThat(changedUids).asList().containsExactly(













                packageSetting1.appId, packageSetting2.appId)













    }



























    @Test













    @Throws(Exception::class)













    fun sendPackagesSuspendedForUser_withDifferentVisibilityAllowList() {













        mockAllowList(packageSetting1, allowList(10001, 10002, 10003))













        mockAllowList(packageSetting2, allowList(10001, 10002, 10007))



























        pms.sendPackagesSuspendedForUser(













                packagesToSuspend, uidsToSuspend, TEST_USER_ID, /* suspended = */ true)













        verify(pms, times(2)).sendPackageBroadcast(any(), nullable(), bundleCaptor.capture(),













                anyInt(), nullable(), nullable(), any(), nullable(), any(), nullable())



























        bundleCaptor.allValues.forEach {













            var changedPackages = it.getStringArray(Intent.EXTRA_CHANGED_PACKAGE_LIST)













            var changedUids = it.getIntArray(Intent.EXTRA_CHANGED_UID_LIST)













            assertThat(changedPackages?.size).isEqualTo(1)













            assertThat(changedUids?.size).isEqualTo(1)













            assertThat(changedPackages?.get(0)).isAnyOf(TEST_PACKAGE_1, TEST_PACKAGE_2)













            assertThat(changedUids?.get(0)).isAnyOf(packageSetting1.appId, packageSetting2.appId)













        }













    }



























    @Test













    @Throws(Exception::class)













    fun sendPackagesSuspendedForUser_withNullVisibilityAllowList() {













        mockAllowList(packageSetting1, allowList(10001, 10002, 10003))













        mockAllowList(packageSetting2, null)



























        pms.sendPackagesSuspendedForUser(













                packagesToSuspend, uidsToSuspend, TEST_USER_ID, /* suspended = */ true)













        verify(pms, times(2)).sendPackageBroadcast(any(), nullable(), bundleCaptor.capture(),













                anyInt(), nullable(), nullable(), any(), nullable(), nullable(), nullable())



























        bundleCaptor.allValues.forEach {













            var changedPackages = it.getStringArray(Intent.EXTRA_CHANGED_PACKAGE_LIST)













            var changedUids = it.getIntArray(Intent.EXTRA_CHANGED_UID_LIST)













            assertThat(changedPackages?.size).isEqualTo(1)













            assertThat(changedUids?.size).isEqualTo(1)













            assertThat(changedPackages?.get(0)).isAnyOf(TEST_PACKAGE_1, TEST_PACKAGE_2)













            assertThat(changedUids?.get(0)).isAnyOf(packageSetting1.appId, packageSetting2.appId)













        }













    }



























    private fun allowList(vararg uids: Int) = SparseArray<IntArray>().apply {













        this.put(TEST_USER_ID, uids)













    }



























    private fun mockAllowList(pkgSetting: PackageSetting, list: SparseArray<IntArray>?) {













        whenever(rule.mocks().injector.appsFilter.getVisibilityAllowList(eq(pkgSetting),













                any(IntArray::class.java), any() as WatchedArrayMap<String, PackageSetting>))













                .thenReturn(list)













    }



























    private fun createPackageManagerService(vararg stageExistingPackages: String):













            PackageManagerService {













        stageExistingPackages.forEach {













            rule.system().stageScanExistingPackage(it, 1L,













                    rule.system().dataAppDirectory)













        }













        var pms = PackageManagerService(rule.mocks().injector,













                false /*coreOnly*/,













                false /*factoryTest*/,













                MockSystem.DEFAULT_VERSION_INFO.fingerprint,













                false /*isEngBuild*/,













                false /*isUserDebugBuild*/,













                Build.VERSION_CODES.CUR_DEVELOPMENT,













                Build.VERSION.INCREMENTAL)













        rule.system().validateFinalState()













        return pms













    }













}
























services/tests/servicestests/utils-mockito/com/android/server/testutils/MockitoUtils.kt



+21
−0




























Original line number
Diff line number
Diff line








@@ -93,3 +93,24 @@ inline fun <reified T> mockThrowOnUnmocked(block: T.() -> Unit = {}) =













        spyThrowOnUnmocked<T>(null, block)































inline fun <reified T : Any> nullable() = ArgumentMatchers.nullable(T::class.java)



























/**













 * Returns Mockito.any() as nullable type to avoid java.lang.IllegalStateException when













 * null is returned.













 *













 * Generic T is nullable because implicitly bounded by Any?.













 */













fun <T> any(type: Class<T>): T = Mockito.any<T>(type)



























/**













 * Wrapper around [Mockito.any] for generic types.













 */













inline fun <reified T> any() = any(T::class.java)



























/**













 * Returns Mockito.eq() as nullable type to avoid java.lang.IllegalStateException when













 * null is returned.













 *













 * Generic T is nullable because implicitly bounded by Any?.













 */













fun <T> eq(obj: T): T = Mockito.eq<T>(obj)