diff --git a/src/com/android/settings/fuelgauge/RestrictAppPreferenceController.java b/src/com/android/settings/fuelgauge/RestrictAppPreferenceController.java index 2b32da19eb9..f282154b669 100644 --- a/src/com/android/settings/fuelgauge/RestrictAppPreferenceController.java +++ b/src/com/android/settings/fuelgauge/RestrictAppPreferenceController.java @@ -43,7 +43,6 @@ public class RestrictAppPreferenceController extends BasePreferenceController { @VisibleForTesting List mAppInfos; private AppOpsManager mAppOpsManager; - private SettingsActivity mSettingsActivity; private InstrumentedPreferenceFragment mPreferenceFragment; private UserManager mUserManager; @@ -53,10 +52,8 @@ public class RestrictAppPreferenceController extends BasePreferenceController { mUserManager = context.getSystemService(UserManager.class); } - public RestrictAppPreferenceController(SettingsActivity settingsActivity, - InstrumentedPreferenceFragment preferenceFragment) { - this(settingsActivity.getApplicationContext()); - mSettingsActivity = settingsActivity; + public RestrictAppPreferenceController(InstrumentedPreferenceFragment preferenceFragment) { + this(preferenceFragment.getContext()); mPreferenceFragment = preferenceFragment; } @@ -83,7 +80,7 @@ public class RestrictAppPreferenceController extends BasePreferenceController { public boolean handlePreferenceTreeClick(Preference preference) { if (getPreferenceKey().equals(preference.getKey())) { // start fragment - RestrictedAppDetails.startRestrictedAppDetails(mSettingsActivity, mPreferenceFragment, + RestrictedAppDetails.startRestrictedAppDetails(mPreferenceFragment, mAppInfos); return true; } diff --git a/src/com/android/settings/fuelgauge/RestrictedAppDetails.java b/src/com/android/settings/fuelgauge/RestrictedAppDetails.java index 58205cbf4f3..a957292bc6f 100644 --- a/src/com/android/settings/fuelgauge/RestrictedAppDetails.java +++ b/src/com/android/settings/fuelgauge/RestrictedAppDetails.java @@ -67,12 +67,12 @@ public class RestrictedAppDetails extends DashboardFragment { private final FooterPreferenceMixin mFooterPreferenceMixin = new FooterPreferenceMixin(this, getLifecycle()); - public static void startRestrictedAppDetails(SettingsActivity caller, - InstrumentedPreferenceFragment fragment, List appInfos) { + public static void startRestrictedAppDetails(InstrumentedPreferenceFragment fragment, + List appInfos) { final Bundle args = new Bundle(); args.putParcelableList(EXTRA_APP_INFO_LIST, appInfos); - new SubSettingLauncher(caller) + new SubSettingLauncher(fragment.getContext()) .setDestination(RestrictedAppDetails.class.getName()) .setArguments(args) .setTitle(R.string.restricted_app_title) diff --git a/src/com/android/settings/fuelgauge/SmartBatterySettings.java b/src/com/android/settings/fuelgauge/SmartBatterySettings.java index ba2b47671f8..ff00d068c49 100644 --- a/src/com/android/settings/fuelgauge/SmartBatterySettings.java +++ b/src/com/android/settings/fuelgauge/SmartBatterySettings.java @@ -73,7 +73,7 @@ public class SmartBatterySettings extends DashboardFragment { controllers.add(new SmartBatteryPreferenceController(context)); if (settingsActivity != null && fragment != null) { controllers.add( - new RestrictAppPreferenceController(settingsActivity, fragment)); + new RestrictAppPreferenceController(fragment)); } else { controllers.add(new RestrictAppPreferenceController(context)); } diff --git a/src/com/android/settings/fuelgauge/batterytip/AnomalyDetectionJobService.java b/src/com/android/settings/fuelgauge/batterytip/AnomalyDetectionJobService.java index c3dd9d658ce..2cc3bae09c1 100644 --- a/src/com/android/settings/fuelgauge/batterytip/AnomalyDetectionJobService.java +++ b/src/com/android/settings/fuelgauge/batterytip/AnomalyDetectionJobService.java @@ -100,6 +100,7 @@ public class AnomalyDetectionJobService extends JobService { .getFactory(this).getPowerUsageFeatureProvider(this); final MetricsFeatureProvider metricsFeatureProvider = FeatureFactory .getFactory(this).getMetricsFeatureProvider(); + batteryUtils.initBatteryStatsHelper(batteryStatsHelper, null /* bundle */, userManager); for (JobWorkItem item = params.dequeueWork(); item != null; item = params.dequeueWork()) { diff --git a/src/com/android/settings/fuelgauge/batterytip/BatteryTipUtils.java b/src/com/android/settings/fuelgauge/batterytip/BatteryTipUtils.java index d3e3da0369c..24c763cb252 100644 --- a/src/com/android/settings/fuelgauge/batterytip/BatteryTipUtils.java +++ b/src/com/android/settings/fuelgauge/batterytip/BatteryTipUtils.java @@ -101,8 +101,7 @@ public class BatteryTipUtils { } case BatteryTip.TipType.APP_RESTRICTION: if (batteryTip.getState() == BatteryTip.StateType.HANDLED) { - return new OpenRestrictAppFragmentAction(settingsActivity, fragment, - (RestrictAppTip) batteryTip); + return new OpenRestrictAppFragmentAction(fragment, (RestrictAppTip) batteryTip); } else { return new RestrictAppAction(settingsActivity, (RestrictAppTip) batteryTip); } diff --git a/src/com/android/settings/fuelgauge/batterytip/actions/OpenRestrictAppFragmentAction.java b/src/com/android/settings/fuelgauge/batterytip/actions/OpenRestrictAppFragmentAction.java index afb80f22886..f9fb9498e9e 100644 --- a/src/com/android/settings/fuelgauge/batterytip/actions/OpenRestrictAppFragmentAction.java +++ b/src/com/android/settings/fuelgauge/batterytip/actions/OpenRestrictAppFragmentAction.java @@ -16,15 +16,16 @@ package com.android.settings.fuelgauge.batterytip.actions; -import android.app.Fragment; +import android.support.annotation.VisibleForTesting; import com.android.internal.logging.nano.MetricsProto; -import com.android.settings.SettingsActivity; import com.android.settings.core.InstrumentedPreferenceFragment; -import com.android.settings.fuelgauge.BatteryUtils; import com.android.settings.fuelgauge.RestrictedAppDetails; +import com.android.settings.fuelgauge.batterytip.AnomalyDatabaseHelper; import com.android.settings.fuelgauge.batterytip.AppInfo; +import com.android.settings.fuelgauge.batterytip.BatteryDatabaseManager; import com.android.settings.fuelgauge.batterytip.tips.RestrictAppTip; +import com.android.settingslib.utils.ThreadUtils; import java.util.List; @@ -33,17 +34,16 @@ import java.util.List; */ public class OpenRestrictAppFragmentAction extends BatteryTipAction { private final RestrictAppTip mRestrictAppTip; - private final BatteryUtils mBatteryUtils; - private final SettingsActivity mSettingsActivity; private final InstrumentedPreferenceFragment mFragment; + @VisibleForTesting + BatteryDatabaseManager mBatteryDatabaseManager; - public OpenRestrictAppFragmentAction(SettingsActivity settingsActivity, - InstrumentedPreferenceFragment fragment, RestrictAppTip tip) { + public OpenRestrictAppFragmentAction(InstrumentedPreferenceFragment fragment, + RestrictAppTip tip) { super(fragment.getContext()); - mSettingsActivity = settingsActivity; mFragment = fragment; mRestrictAppTip = tip; - mBatteryUtils = BatteryUtils.getInstance(mContext); + mBatteryDatabaseManager = BatteryDatabaseManager.getInstance(mContext); } /** @@ -54,7 +54,10 @@ public class OpenRestrictAppFragmentAction extends BatteryTipAction { mMetricsFeatureProvider.action(mContext, MetricsProto.MetricsEvent.ACTION_TIP_OPEN_APP_RESTRICTION_PAGE, metricsKey); final List mAppInfos = mRestrictAppTip.getRestrictAppList(); - RestrictedAppDetails.startRestrictedAppDetails(mSettingsActivity, mFragment, - mAppInfos); + RestrictedAppDetails.startRestrictedAppDetails(mFragment, mAppInfos); + + // Mark all the anomalies as handled, so it won't show up again. + ThreadUtils.postOnBackgroundThread(() -> mBatteryDatabaseManager.updateAnomalies(mAppInfos, + AnomalyDatabaseHelper.State.HANDLED)); } } diff --git a/src/com/android/settings/fuelgauge/batterytip/detectors/RestrictAppDetector.java b/src/com/android/settings/fuelgauge/batterytip/detectors/RestrictAppDetector.java index c251f76ae45..3ff0989d08a 100644 --- a/src/com/android/settings/fuelgauge/batterytip/detectors/RestrictAppDetector.java +++ b/src/com/android/settings/fuelgauge/batterytip/detectors/RestrictAppDetector.java @@ -20,18 +20,17 @@ import android.content.Context; import androidx.annotation.VisibleForTesting; import android.text.format.DateUtils; -import com.android.settings.Utils; import com.android.settings.fuelgauge.batterytip.AnomalyDatabaseHelper; import com.android.settings.fuelgauge.batterytip.AppInfo; import com.android.settings.fuelgauge.batterytip.BatteryDatabaseManager; import com.android.settings.fuelgauge.batterytip.BatteryTipPolicy; -import com.android.settings.fuelgauge.batterytip.tips.AppInfoPredicate; +import com.android.settings.fuelgauge.batterytip.tips.AppLabelPredicate; +import com.android.settings.fuelgauge.batterytip.tips.AppRestrictionPredicate; import com.android.settings.fuelgauge.batterytip.tips.BatteryTip; import com.android.settings.fuelgauge.batterytip.tips.RestrictAppTip; import java.util.ArrayList; import java.util.List; -import java.util.function.Predicate; /** * Detector whether to show summary tip. This detector should be executed as the last @@ -45,13 +44,15 @@ public class RestrictAppDetector implements BatteryTipDetector { BatteryDatabaseManager mBatteryDatabaseManager; private Context mContext; - private AppInfoPredicate mAppInfoPredicate; + private AppRestrictionPredicate mAppRestrictionPredicate; + private AppLabelPredicate mAppLabelPredicate; public RestrictAppDetector(Context context, BatteryTipPolicy policy) { mContext = context; mPolicy = policy; mBatteryDatabaseManager = BatteryDatabaseManager.getInstance(context); - mAppInfoPredicate = new AppInfoPredicate(context); + mAppRestrictionPredicate = new AppRestrictionPredicate(context); + mAppLabelPredicate = new AppLabelPredicate(context); } @Override @@ -64,7 +65,8 @@ public class RestrictAppDetector implements BatteryTipDetector { final long oneDayBeforeMs = System.currentTimeMillis() - DateUtils.DAY_IN_MILLIS; final List highUsageApps = mBatteryDatabaseManager.queryAllAnomalies( oneDayBeforeMs, AnomalyDatabaseHelper.State.NEW); - highUsageApps.removeIf(mAppInfoPredicate); + // Remove it if it doesn't have label or been restricted + highUsageApps.removeIf(mAppLabelPredicate.or(mAppRestrictionPredicate)); if (!highUsageApps.isEmpty()) { // If there are new anomalies, show them return new RestrictAppTip(BatteryTip.StateType.NEW, highUsageApps); @@ -72,7 +74,8 @@ public class RestrictAppDetector implements BatteryTipDetector { // Otherwise, show auto-handled one if it exists final List autoHandledApps = mBatteryDatabaseManager.queryAllAnomalies( oneDayBeforeMs, AnomalyDatabaseHelper.State.AUTO_HANDLED); - autoHandledApps.removeIf(mAppInfoPredicate); + // Remove it if it doesn't have label or unrestricted + autoHandledApps.removeIf(mAppLabelPredicate.or(mAppRestrictionPredicate.negate())); return new RestrictAppTip(autoHandledApps.isEmpty() ? BatteryTip.StateType.INVISIBLE : BatteryTip.StateType.HANDLED, autoHandledApps); } diff --git a/src/com/android/settings/fuelgauge/batterytip/tips/AppInfoPredicate.java b/src/com/android/settings/fuelgauge/batterytip/tips/AppLabelPredicate.java similarity index 76% rename from src/com/android/settings/fuelgauge/batterytip/tips/AppInfoPredicate.java rename to src/com/android/settings/fuelgauge/batterytip/tips/AppLabelPredicate.java index df78caaf4a8..13a2452bb23 100644 --- a/src/com/android/settings/fuelgauge/batterytip/tips/AppInfoPredicate.java +++ b/src/com/android/settings/fuelgauge/batterytip/tips/AppLabelPredicate.java @@ -25,22 +25,20 @@ import com.android.settings.fuelgauge.batterytip.AppInfo; import java.util.function.Predicate; /** - * {@link Predicate} for {@link AppInfo} to check whether it has label or restricted. + * {@link Predicate} for {@link AppInfo} to check whether it has label */ -public class AppInfoPredicate implements Predicate { +public class AppLabelPredicate implements Predicate { private Context mContext; private AppOpsManager mAppOpsManager; - public AppInfoPredicate(Context context) { + public AppLabelPredicate(Context context) { mContext = context; mAppOpsManager = context.getSystemService(AppOpsManager.class); } @Override public boolean test(AppInfo appInfo) { - // Return true if app doesn't have label or already been restricted - return Utils.getApplicationLabel(mContext, appInfo.packageName) == null - || mAppOpsManager.checkOpNoThrow(AppOpsManager.OP_RUN_ANY_IN_BACKGROUND, - appInfo.uid, appInfo.packageName) == AppOpsManager.MODE_IGNORED; + // Return true if app doesn't have label + return Utils.getApplicationLabel(mContext, appInfo.packageName) == null; } } diff --git a/src/com/android/settings/fuelgauge/batterytip/tips/AppRestrictionPredicate.java b/src/com/android/settings/fuelgauge/batterytip/tips/AppRestrictionPredicate.java new file mode 100644 index 00000000000..21bdbf10816 --- /dev/null +++ b/src/com/android/settings/fuelgauge/batterytip/tips/AppRestrictionPredicate.java @@ -0,0 +1,43 @@ +/* + * Copyright (C) 2018 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.settings.fuelgauge.batterytip.tips; + +import android.app.AppOpsManager; +import android.content.Context; + +import com.android.settings.Utils; +import com.android.settings.fuelgauge.batterytip.AppInfo; + +import java.util.function.Predicate; + +/** + * {@link Predicate} for {@link AppInfo} to check whether it is restricted. + */ +public class AppRestrictionPredicate implements Predicate { + private AppOpsManager mAppOpsManager; + + public AppRestrictionPredicate(Context context) { + mAppOpsManager = context.getSystemService(AppOpsManager.class); + } + + @Override + public boolean test(AppInfo appInfo) { + // Return true if app already been restricted + return mAppOpsManager.checkOpNoThrow(AppOpsManager.OP_RUN_ANY_IN_BACKGROUND, + appInfo.uid, appInfo.packageName) == AppOpsManager.MODE_IGNORED; + } +} diff --git a/tests/robotests/src/com/android/settings/fuelgauge/RestrictAppPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/fuelgauge/RestrictAppPreferenceControllerTest.java index 8f4bd3d9768..c6f885cc5bf 100644 --- a/tests/robotests/src/com/android/settings/fuelgauge/RestrictAppPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/fuelgauge/RestrictAppPreferenceControllerTest.java @@ -67,8 +67,6 @@ public class RestrictAppPreferenceControllerTest { @Mock private AppOpsManager.PackageOps mOtherUserPackageOps; @Mock - private SettingsActivity mSettingsActivity; - @Mock private InstrumentedPreferenceFragment mFragment; @Mock private UserManager mUserManager; @@ -102,9 +100,9 @@ public class RestrictAppPreferenceControllerTest { mContext = spy(RuntimeEnvironment.application); doReturn(mAppOpsManager).when(mContext).getSystemService(Context.APP_OPS_SERVICE); doReturn(mUserManager).when(mContext).getSystemService(UserManager.class); - doReturn(mContext).when(mSettingsActivity).getApplicationContext(); + doReturn(mContext).when(mFragment).getContext(); mRestrictAppPreferenceController = - new RestrictAppPreferenceController(mSettingsActivity, mFragment); + new RestrictAppPreferenceController(mFragment); mPackageOpsList = new ArrayList<>(); mPreference = new Preference(mContext); mPreference.setKey(mRestrictAppPreferenceController.getPreferenceKey()); @@ -171,7 +169,7 @@ public class RestrictAppPreferenceControllerTest { mRestrictAppPreferenceController.handlePreferenceTreeClick(mPreference); - verify(mSettingsActivity).startActivity(intent.capture()); + verify(mContext).startActivity(intent.capture()); assertThat(intent.getValue().getStringExtra(EXTRA_SHOW_FRAGMENT)) .isEqualTo(RestrictedAppDetails.class.getName()); assertThat(intent.getValue().getIntExtra(EXTRA_SHOW_FRAGMENT_TITLE_RESID, -1)) diff --git a/tests/robotests/src/com/android/settings/fuelgauge/RestrictedAppDetailsTest.java b/tests/robotests/src/com/android/settings/fuelgauge/RestrictedAppDetailsTest.java index e187694aa50..a4b21819701 100644 --- a/tests/robotests/src/com/android/settings/fuelgauge/RestrictedAppDetailsTest.java +++ b/tests/robotests/src/com/android/settings/fuelgauge/RestrictedAppDetailsTest.java @@ -69,8 +69,6 @@ public class RestrictedAppDetailsTest { @Mock(answer = Answers.RETURNS_DEEP_STUBS) private PreferenceManager mPreferenceManager; @Mock - private SettingsActivity mSettingsActivity; - @Mock private InstrumentedPreferenceFragment mFragment; private RestrictedAppDetails mRestrictedAppDetails; private Context mContext; @@ -90,6 +88,7 @@ public class RestrictedAppDetailsTest { doReturn(mPreferenceManager).when(mRestrictedAppDetails).getPreferenceManager(); doReturn(mContext).when(mPreferenceManager).getContext(); + doReturn(mContext).when(mFragment).getContext(); mRestrictedAppDetails.mPackageManager = mPackageManager; mRestrictedAppDetails.mIconDrawableFactory = mIconDrawableFactory; mRestrictedAppDetails.mAppInfos = new ArrayList<>(); @@ -124,9 +123,9 @@ public class RestrictedAppDetailsTest { // Get the intent in which it has the app info bundle mIntent = captor.getValue(); return true; - }).when(mSettingsActivity).startActivity(captor.capture()); + }).when(mContext).startActivity(captor.capture()); - RestrictedAppDetails.startRestrictedAppDetails(mSettingsActivity, mFragment, + RestrictedAppDetails.startRestrictedAppDetails(mFragment, mRestrictedAppDetails.mAppInfos); final Bundle bundle = mIntent.getBundleExtra( diff --git a/tests/robotests/src/com/android/settings/fuelgauge/batterytip/actions/OpenRestrictAppFragmentActionTest.java b/tests/robotests/src/com/android/settings/fuelgauge/batterytip/actions/OpenRestrictAppFragmentActionTest.java new file mode 100644 index 00000000000..39555b2ba9d --- /dev/null +++ b/tests/robotests/src/com/android/settings/fuelgauge/batterytip/actions/OpenRestrictAppFragmentActionTest.java @@ -0,0 +1,99 @@ +/* + * Copyright (C) 2018 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.settings.fuelgauge.batterytip.actions; + +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import android.content.Context; + +import com.android.internal.logging.nano.MetricsProto; +import com.android.settings.core.InstrumentedPreferenceFragment; +import com.android.settings.fuelgauge.batterytip.AnomalyDatabaseHelper; +import com.android.settings.fuelgauge.batterytip.AppInfo; +import com.android.settings.fuelgauge.batterytip.BatteryDatabaseManager; +import com.android.settings.fuelgauge.batterytip.tips.BatteryTip; +import com.android.settings.fuelgauge.batterytip.tips.RestrictAppTip; +import com.android.settings.testutils.DatabaseTestUtils; +import com.android.settings.testutils.FakeFeatureFactory; +import com.android.settings.testutils.SettingsRobolectricTestRunner; + +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.robolectric.RuntimeEnvironment; + +import java.util.ArrayList; +import java.util.List; + +@RunWith(SettingsRobolectricTestRunner.class) +public class OpenRestrictAppFragmentActionTest { + + private static final String PACKAGE_NAME_1 = "com.android.app1"; + private static final String PACKAGE_NAME_2 = "com.android.app2"; + private static final int ANOMALY_WAKEUP = 0; + private static final int ANOMALY_BT = 1; + private static final int METRICS_KEY = 1; + + @Mock + private InstrumentedPreferenceFragment mFragment; + @Mock + private BatteryDatabaseManager mBatteryDatabaseManager; + private OpenRestrictAppFragmentAction mAction; + private FakeFeatureFactory mFeatureFactory; + private Context mContext; + private List mAppInfos; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + mContext = RuntimeEnvironment.application; + + mAppInfos = new ArrayList<>(); + mAppInfos.add(new AppInfo.Builder() + .setPackageName(PACKAGE_NAME_1) + .addAnomalyType(ANOMALY_BT) + .build()); + mAppInfos.add(new AppInfo.Builder() + .setPackageName(PACKAGE_NAME_2) + .addAnomalyType(ANOMALY_WAKEUP) + .build()); + mFeatureFactory = FakeFeatureFactory.setupForTest(); + when(mFragment.getContext()).thenReturn(mContext); + + mAction = new OpenRestrictAppFragmentAction(mFragment, + new RestrictAppTip(BatteryTip.StateType.HANDLED, mAppInfos)); + mAction.mBatteryDatabaseManager = mBatteryDatabaseManager; + } + + @After + public void cleanUp() { + DatabaseTestUtils.clearDb(mContext); + } + + @Test + public void testHandlePositiveAction() { + mAction.handlePositiveAction(METRICS_KEY); + + verify(mFeatureFactory.metricsFeatureProvider).action(mContext, + MetricsProto.MetricsEvent.ACTION_TIP_OPEN_APP_RESTRICTION_PAGE, METRICS_KEY); + verify(mBatteryDatabaseManager).updateAnomalies(mAppInfos, + AnomalyDatabaseHelper.State.HANDLED); + } +} diff --git a/tests/robotests/src/com/android/settings/fuelgauge/batterytip/detectors/RestrictAppDetectorTest.java b/tests/robotests/src/com/android/settings/fuelgauge/batterytip/detectors/RestrictAppDetectorTest.java index 76e2928cb9d..a8989a0962e 100644 --- a/tests/robotests/src/com/android/settings/fuelgauge/batterytip/detectors/RestrictAppDetectorTest.java +++ b/tests/robotests/src/com/android/settings/fuelgauge/batterytip/detectors/RestrictAppDetectorTest.java @@ -55,9 +55,11 @@ import java.util.List; public class RestrictAppDetectorTest { private static final int RESTRICTED_UID = 222; + private static final int UNRESTRICTED_UID = 333; private static final String PACKAGE_NAME = "com.android.app"; private static final String UNINSTALLED_PACKAGE_NAME = "com.android.uninstalled"; private static final String RESTRICTED_PACKAGE_NAME = "com.android.restricted"; + private static final String UNRESTRICTED_PACKAGE_NAME = "com.android.unrestricted"; private Context mContext; private BatteryTipPolicy mPolicy; private RestrictAppDetector mRestrictAppDetector; @@ -88,9 +90,12 @@ public class RestrictAppDetectorTest { doReturn(mAppOpsManager).when(mContext).getSystemService(AppOpsManager.class); doReturn(AppOpsManager.MODE_IGNORED).when(mAppOpsManager).checkOpNoThrow( AppOpsManager.OP_RUN_ANY_IN_BACKGROUND, RESTRICTED_UID, RESTRICTED_PACKAGE_NAME); + doReturn(AppOpsManager.MODE_ALLOWED).when(mAppOpsManager).checkOpNoThrow( + AppOpsManager.OP_RUN_ANY_IN_BACKGROUND, UNRESTRICTED_UID, + UNRESTRICTED_PACKAGE_NAME); doReturn(mPackageManager).when(mContext).getPackageManager(); - doReturn(mApplicationInfo).when(mPackageManager).getApplicationInfo(eq(PACKAGE_NAME), + doReturn(mApplicationInfo).when(mPackageManager).getApplicationInfo(any(), anyInt()); doReturn(PACKAGE_NAME).when(mApplicationInfo).loadLabel(any()); doThrow(new PackageManager.NameNotFoundException()).when( @@ -116,6 +121,10 @@ public class RestrictAppDetectorTest { @Test public void testDetect_hasAutoHandledAnomaly_tipHandled() { + mAppInfoList.add(new AppInfo.Builder() + .setUid(RESTRICTED_UID) + .setPackageName(RESTRICTED_PACKAGE_NAME) + .build()); doReturn(new ArrayList()).when(mBatteryDatabaseManager) .queryAllAnomalies(anyLong(), eq(AnomalyDatabaseHelper.State.NEW)); doReturn(mAppInfoList).when(mBatteryDatabaseManager) @@ -126,7 +135,7 @@ public class RestrictAppDetectorTest { } @Test - public void testDetect_hasUninstalledAnomaly_removeIt() { + public void testDetect_typeNewHasUninstalledAnomaly_removeIt() { mAppInfoList.add(new AppInfo.Builder() .setPackageName(UNINSTALLED_PACKAGE_NAME) .build()); @@ -139,7 +148,7 @@ public class RestrictAppDetectorTest { } @Test - public void testDetect_hasRestrictedAnomaly_removeIt() throws + public void testDetect_typeNewHasRestrictedAnomaly_removeIt() throws PackageManager.NameNotFoundException { mAppInfoList.add(new AppInfo.Builder() .setUid(RESTRICTED_UID) @@ -155,6 +164,25 @@ public class RestrictAppDetectorTest { assertThat(restrictAppTip.getRestrictAppList()).containsExactly(mAppInfo); } + @Test + public void testDetect_typeHandledHasUnRestrictedAnomaly_removeIt() throws + PackageManager.NameNotFoundException { + mAppInfoList.clear(); + mAppInfoList.add(new AppInfo.Builder() + .setUid(UNRESTRICTED_UID) + .setPackageName(UNRESTRICTED_PACKAGE_NAME) + .build()); + doReturn(new ArrayList<>()).when(mBatteryDatabaseManager) + .queryAllAnomalies(anyLong(), eq(AnomalyDatabaseHelper.State.NEW)); + doReturn(mAppInfoList).when(mBatteryDatabaseManager) + .queryAllAnomalies(anyLong(), eq(AnomalyDatabaseHelper.State.AUTO_HANDLED)); + doReturn(mApplicationInfo).when(mPackageManager).getApplicationInfo( + eq(UNRESTRICTED_PACKAGE_NAME), anyInt()); + + final RestrictAppTip restrictAppTip = (RestrictAppTip) mRestrictAppDetector.detect(); + assertThat(restrictAppTip.getState()).isEqualTo(BatteryTip.StateType.INVISIBLE); + } + @Test public void testDetect_noAnomaly_tipInvisible() { doReturn(new ArrayList()).when(mBatteryDatabaseManager) diff --git a/tests/unit/src/com/android/settings/fuelgauge/batterytip/RestrictAppTest.java b/tests/unit/src/com/android/settings/fuelgauge/batterytip/RestrictAppTest.java index b3842d28162..5d68c76e641 100644 --- a/tests/unit/src/com/android/settings/fuelgauge/batterytip/RestrictAppTest.java +++ b/tests/unit/src/com/android/settings/fuelgauge/batterytip/RestrictAppTest.java @@ -55,7 +55,7 @@ public class RestrictAppTest { } @Test - public void testBatterySettings_hasOneAnomaly_showAnomaly() throws + public void batterySettings_hasOneAnomaly_showAnomaly() throws PackageManager.NameNotFoundException { mBatteryDatabaseManager.insertAnomaly(mPackageManager.getPackageUid(PACKAGE_SETTINGS, 0), PACKAGE_SETTINGS, 1, @@ -67,7 +67,7 @@ public class RestrictAppTest { } @Test - public void testBatterySettings_hasTwoAnomalies_showAnomalies() throws + public void batterySettings_hasTwoAnomalies_showAnomalies() throws PackageManager.NameNotFoundException { mBatteryDatabaseManager.insertAnomaly(mPackageManager.getPackageUid(PACKAGE_SETTINGS, 0), PACKAGE_SETTINGS, 1, @@ -80,4 +80,19 @@ public class RestrictAppTest { instrumentation.startActivitySync(new Intent(BATTERY_INTENT)); onView(withText("Restrict 2 apps")).check(matches(isDisplayed())); } + + @Test + public void batterySettings_hasAutoHandledAnomalies_showAutoHandled() throws + PackageManager.NameNotFoundException { + mBatteryDatabaseManager.insertAnomaly(mPackageManager.getPackageUid(PACKAGE_SETTINGS, 0), + PACKAGE_SETTINGS, 1, + AnomalyDatabaseHelper.State.AUTO_HANDLED, System.currentTimeMillis()); + mBatteryDatabaseManager.insertAnomaly(mPackageManager.getPackageUid(PACKAGE_SYSTEM_UI, 0), + PACKAGE_SYSTEM_UI, 1, + AnomalyDatabaseHelper.State.AUTO_HANDLED, System.currentTimeMillis()); + + Instrumentation instrumentation = InstrumentationRegistry.getInstrumentation(); + instrumentation.startActivitySync(new Intent(BATTERY_INTENT)); + onView(withText("2 apps recently restricted")).check(matches(isDisplayed())); + } }