Merge "Fix bugs in auto restriction." into pi-dev am: f6e2c19fcc

am: a9e4d4a42a

Change-Id: If82969696eb492ea3875a0e0fb92f038024f00f9

src/com/android/settings/fuelgauge/RestrictAppPreferenceController.java

@@ -43,7 +43,6 @@ public class RestrictAppPreferenceController extends BasePreferenceController {
     @VisibleForTesting
     List<AppInfo> 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,
+    public RestrictAppPreferenceController(InstrumentedPreferenceFragment preferenceFragment) {
-            InstrumentedPreferenceFragment preferenceFragment) {
+        this(preferenceFragment.getContext());
-        this(settingsActivity.getApplicationContext());
-        mSettingsActivity = settingsActivity;
         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;
         }

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,
+    public static void startRestrictedAppDetails(InstrumentedPreferenceFragment fragment,
-            InstrumentedPreferenceFragment fragment, List<AppInfo> appInfos) {
+            List<AppInfo> 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)

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

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()) {

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,
+                    return new OpenRestrictAppFragmentAction(fragment, (RestrictAppTip) batteryTip);
-                            (RestrictAppTip) batteryTip);
                 } else {
                     return new RestrictAppAction(settingsActivity, (RestrictAppTip) batteryTip);
                 }

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,
+    public OpenRestrictAppFragmentAction(InstrumentedPreferenceFragment fragment,
-            InstrumentedPreferenceFragment fragment, RestrictAppTip tip) {
+            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<AppInfo> mAppInfos = mRestrictAppTip.getRestrictAppList();
-        RestrictedAppDetails.startRestrictedAppDetails(mSettingsActivity, mFragment,
+        RestrictedAppDetails.startRestrictedAppDetails(mFragment, mAppInfos);
-                mAppInfos);
+
+        // Mark all the anomalies as handled, so it won't show up again.
+        ThreadUtils.postOnBackgroundThread(() -> mBatteryDatabaseManager.updateAnomalies(mAppInfos,
+                AnomalyDatabaseHelper.State.HANDLED));
     }
 }

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

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<AppInfo> {
+public class AppLabelPredicate implements Predicate<AppInfo> {
     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 true if app doesn't have label
-        return Utils.getApplicationLabel(mContext, appInfo.packageName) == null
+        return Utils.getApplicationLabel(mContext, appInfo.packageName) == null;
-                || mAppOpsManager.checkOpNoThrow(AppOpsManager.OP_RUN_ANY_IN_BACKGROUND,
-                appInfo.uid, appInfo.packageName) == AppOpsManager.MODE_IGNORED;
     }
 }

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<AppInfo> {
+    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;
+    }
+}

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))

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(

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<AppInfo> 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);
+    }
+}

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<AppInfo>()).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<AppInfo>()).when(mBatteryDatabaseManager)

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()));
+    }
 }