Merge "Pull unused app count from PermissionController" (c721a44f) · Commits · e / os / android_packages_apps_Settings

src/com/android/settings/applications/HibernatedAppsPreferenceController.java

+8 −90

Original line number	Diff line number	Diff line
		@@ -16,22 +16,14 @@

		package com.android.settings.applications;

		import static android.app.usage.UsageStatsManager.INTERVAL_MONTHLY;
		import static android.provider.DeviceConfig.NAMESPACE_APP_HIBERNATION;

		import static com.android.settings.Utils.PROPERTY_APP_HIBERNATION_ENABLED;

		import android.app.usage.UsageStats;
		import android.app.usage.UsageStatsManager;
		import android.apphibernation.AppHibernationManager;
		import android.content.Context;
		import android.content.pm.PackageInfo;
		import android.content.pm.PackageManager;
		import android.permission.PermissionControllerManager;
		import android.provider.DeviceConfig;
		import android.util.ArrayMap;

		import androidx.annotation.NonNull;
		import androidx.annotation.WorkerThread;
		import androidx.lifecycle.Lifecycle;
		import androidx.lifecycle.LifecycleObserver;
		import androidx.lifecycle.OnLifecycleEvent;
		@@ -43,11 +35,7 @@ import com.android.settings.core.BasePreferenceController;

		import com.google.common.annotations.VisibleForTesting;

		import java.util.List;
		import java.util.Map;
		import java.util.concurrent.Executor;
		import java.util.concurrent.Executors;
		import java.util.concurrent.TimeUnit;

		/**
		* A preference controller handling the logic for updating summary of hibernated apps.
		@@ -55,26 +43,20 @@ import java.util.concurrent.TimeUnit;
		public final class HibernatedAppsPreferenceController extends BasePreferenceController
		implements LifecycleObserver {
		private static final String TAG = "HibernatedAppsPrefController";
		private static final String PROPERTY_HIBERNATION_UNUSED_THRESHOLD_MILLIS =
		"auto_revoke_unused_threshold_millis2";
		private static final long DEFAULT_UNUSED_THRESHOLD_MS = TimeUnit.DAYS.toMillis(90);
		private PreferenceScreen mScreen;
		private int mUnusedCount = 0;
		private boolean mLoadingUnusedApps;
		private boolean mLoadedUnusedCount;
		private final Executor mBackgroundExecutor;
		private final Executor mMainExecutor;

		public HibernatedAppsPreferenceController(Context context, String preferenceKey) {
		this(context, preferenceKey, Executors.newSingleThreadExecutor(),
		context.getMainExecutor());
		this(context, preferenceKey, context.getMainExecutor());
		}

		@VisibleForTesting
		HibernatedAppsPreferenceController(Context context, String preferenceKey,
		Executor bgExecutor, Executor mainExecutor) {
		Executor mainExecutor) {
		super(context, preferenceKey);
		mBackgroundExecutor = bgExecutor;
		mMainExecutor = mainExecutor;
		}

		@@ -110,85 +92,21 @@ public final class HibernatedAppsPreferenceController extends BasePreferenceCont
		return;
		}
		if (!mLoadingUnusedApps) {
		loadUnusedCount(unusedCount -> {
		final PermissionControllerManager permController =
		mContext.getSystemService(PermissionControllerManager.class);
		permController.getUnusedAppCount(mMainExecutor, unusedCount -> {
		mUnusedCount = unusedCount;
		mLoadingUnusedApps = false;
		mLoadedUnusedCount = true;
		mMainExecutor.execute(() -> {
		Preference pref = mScreen.findPreference(mPreferenceKey);
		refreshSummary(pref);
		});
		});
		mLoadingUnusedApps = true;
		}
		}

		/**
		* Asynchronously load the count of unused apps.
		*
		* @param callback callback to call when the number of unused apps is calculated
		*/
		private void loadUnusedCount(@NonNull UnusedCountLoadedCallback callback) {
		mBackgroundExecutor.execute(() -> {
		final int unusedCount = getUnusedCount();
		callback.onUnusedCountLoaded(unusedCount);
		});
		}

		@WorkerThread
		private int getUnusedCount() {
		// TODO(b/187465752): Find a way to export this logic from PermissionController module
		final PackageManager pm = mContext.getPackageManager();
		final AppHibernationManager ahm = mContext.getSystemService(AppHibernationManager.class);
		final List<String> hibernatedPackages = ahm.getHibernatingPackagesForUser();
		int numHibernated = hibernatedPackages.size();

		// Also need to count packages that are auto revoked but not hibernated.
		int numAutoRevoked = 0;
		final UsageStatsManager usm = mContext.getSystemService(UsageStatsManager.class);
		final long now = System.currentTimeMillis();
		final long unusedThreshold = DeviceConfig.getLong(DeviceConfig.NAMESPACE_PERMISSIONS,
		PROPERTY_HIBERNATION_UNUSED_THRESHOLD_MILLIS, DEFAULT_UNUSED_THRESHOLD_MS);
		final List<UsageStats> usageStatsList = usm.queryUsageStats(INTERVAL_MONTHLY,
		now - unusedThreshold, now);
		final Map<String, UsageStats> recentlyUsedPackages = new ArrayMap<>();
		for (UsageStats us : usageStatsList) {
		recentlyUsedPackages.put(us.mPackageName, us);
		}
		final List<PackageInfo> packages = pm.getInstalledPackages(
		PackageManager.MATCH_DISABLED_COMPONENTS \| PackageManager.GET_PERMISSIONS);
		for (PackageInfo pi : packages) {
		final String packageName = pi.packageName;
		final UsageStats usageStats = recentlyUsedPackages.get(packageName);
		// Only count packages that have not been used recently as auto-revoked permissions may
		// stay revoked even after use if the user has not regranted them.
		final boolean usedRecently = (usageStats != null
		&& (now - usageStats.getLastTimeAnyComponentUsed() < unusedThreshold
		\|\| now - usageStats.getLastTimeVisible() < unusedThreshold));
		if (!hibernatedPackages.contains(packageName)
		&& pi.requestedPermissions != null
		&& !usedRecently) {
		for (String perm : pi.requestedPermissions) {
		if ((pm.getPermissionFlags(perm, packageName, mContext.getUser())
		& PackageManager.FLAG_PERMISSION_AUTO_REVOKED) != 0) {
		numAutoRevoked++;
		break;
		}
		}
		}
		}
		return numHibernated + numAutoRevoked;
		}

		private static boolean isHibernationEnabled() {
		return DeviceConfig.getBoolean(
		NAMESPACE_APP_HIBERNATION, PROPERTY_APP_HIBERNATION_ENABLED, true);
		}

		/**
		* Callback for when we've determined the number of unused apps.
		*/
		private interface UnusedCountLoadedCallback {
		void onUnusedCountLoaded(int unusedCount);
		}
		}

tests/unit/src/com/android/settings/applications/HibernatedAppsPreferenceControllerTest.java

+1 −91

Original line number	Diff line number	Diff line
		@@ -23,26 +23,16 @@ import static com.android.settings.core.BasePreferenceController.AVAILABLE;

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

		import static org.mockito.ArgumentMatchers.anyInt;
		import static org.mockito.ArgumentMatchers.anyLong;
		import static org.mockito.ArgumentMatchers.anyString;
		import static org.mockito.ArgumentMatchers.eq;
		import static org.mockito.Mockito.mock;
		import static org.mockito.Mockito.spy;
		import static org.mockito.Mockito.verify;
		import static org.mockito.Mockito.when;

		import android.app.usage.IUsageStatsManager;
		import android.app.usage.UsageStats;
		import android.app.usage.UsageStatsManager;
		import android.apphibernation.AppHibernationManager;
		import android.content.Context;
		import android.content.pm.PackageInfo;
		import android.content.pm.PackageManager;
		import android.content.pm.ParceledListSlice;
		import android.content.res.Resources;
		import android.os.Looper;
		import android.os.RemoteException;
		import android.provider.DeviceConfig;

		import androidx.preference.Preference;
		@@ -57,14 +47,9 @@ import org.junit.runner.RunWith;
		import org.mockito.Mock;
		import org.mockito.MockitoAnnotations;

		import java.util.Arrays;

		@RunWith(AndroidJUnit4.class)
		public class HibernatedAppsPreferenceControllerTest {

		public static final String HIBERNATED_PACKAGE_NAME = "hibernated_package";
		public static final String AUTO_REVOKED_PACKAGE_NAME = "auto_revoked_package";
		public static final String PERMISSION = "permission";
		@Mock
		PackageManager mPackageManager;
		@Mock
		@@ -98,7 +83,7 @@ public class HibernatedAppsPreferenceControllerTest {
		mPreferenceScreen.addPreference(preference);

		mController = new HibernatedAppsPreferenceController(mContext, KEY,
		command -> command.run(), command -> command.run());
		command -> command.run());
		}

		@Test
		@@ -108,79 +93,4 @@ public class HibernatedAppsPreferenceControllerTest {

		assertThat((mController).getAvailabilityStatus()).isNotEqualTo(AVAILABLE);
		}

		@Test
		public void getSummary_getsRightCountForHibernatedPackage() {
		final PackageInfo hibernatedPkg = getHibernatedPackage();
		when(mPackageManager.getInstalledPackages(anyInt())).thenReturn(
		Arrays.asList(hibernatedPkg, new PackageInfo()));
		when(mContext.getResources()).thenReturn(mock(Resources.class));

		mController.displayPreference(mPreferenceScreen);
		mController.onResume();

		verify(mContext.getResources()).getQuantityString(anyInt(), eq(1), eq(1));
		}

		@Test
		public void getSummary_getsRightCountForUnusedAutoRevokedPackage() {
		final PackageInfo autoRevokedPkg = getAutoRevokedPackage();
		when(mPackageManager.getInstalledPackages(anyInt())).thenReturn(
		Arrays.asList(autoRevokedPkg, new PackageInfo()));
		when(mContext.getResources()).thenReturn(mock(Resources.class));

		mController.displayPreference(mPreferenceScreen);
		mController.onResume();

		verify(mContext.getResources()).getQuantityString(anyInt(), eq(1), eq(1));
		}

		@Test
		public void getSummary_getsRightCountForUsedAutoRevokedPackage() {
		final PackageInfo usedAutoRevokedPkg = getAutoRevokedPackage();
		setAutoRevokedPackageUsageStats();
		when(mPackageManager.getInstalledPackages(anyInt())).thenReturn(
		Arrays.asList(usedAutoRevokedPkg, new PackageInfo()));
		when(mContext.getResources()).thenReturn(mock(Resources.class));

		mController.displayPreference(mPreferenceScreen);
		mController.onResume();

		verify(mContext.getResources()).getQuantityString(anyInt(), eq(0), eq(0));
		}

		private PackageInfo getHibernatedPackage() {
		final PackageInfo pi = new PackageInfo();
		pi.packageName = HIBERNATED_PACKAGE_NAME;
		pi.requestedPermissions = new String[] {PERMISSION};
		when(mAppHibernationManager.getHibernatingPackagesForUser())
		.thenReturn(Arrays.asList(pi.packageName));
		when(mPackageManager.getPermissionFlags(
		pi.requestedPermissions[0], pi.packageName, mContext.getUser()))
		.thenReturn(PackageManager.FLAG_PERMISSION_AUTO_REVOKED);
		return pi;
		}

		private PackageInfo getAutoRevokedPackage() {
		final PackageInfo pi = new PackageInfo();
		pi.packageName = AUTO_REVOKED_PACKAGE_NAME;
		pi.requestedPermissions = new String[] {PERMISSION};
		when(mPackageManager.getPermissionFlags(
		pi.requestedPermissions[0], pi.packageName, mContext.getUser()))
		.thenReturn(PackageManager.FLAG_PERMISSION_AUTO_REVOKED);
		return pi;
		}

		private void setAutoRevokedPackageUsageStats() {
		final UsageStats us = new UsageStats();
		us.mPackageName = AUTO_REVOKED_PACKAGE_NAME;
		us.mLastTimeVisible = System.currentTimeMillis();
		try {
		when(mIUsageStatsManager.queryUsageStats(
		anyInt(), anyLong(), anyLong(), anyString(), anyInt()))
		.thenReturn(new ParceledListSlice(Arrays.asList(us)));
		} catch (RemoteException e) {
		// no-op
		}
		}
		}