PawletOS/app_Settings
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Pull unused app count from PermissionController"

Browse Source
This commit is contained in:
Kevin Han
2022-01-27 23:50:03 +00:00
committed by Android (Google) Code Review
parent a36e4349ba 350a1785de
commit c721a44f20
2 changed files with 9 additions and 181 deletions
Download Patch File Download Diff File Expand all files Collapse all files

98
src/com/android/settings/applications/HibernatedAppsPreferenceController.java
View File

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

92
tests/unit/src/com/android/settings/applications/HibernatedAppsPreferenceControllerTest.java
View File

@@ -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
}
}
}