Add high usage battery tip

1. Add both model and detector
2. Move the screen usage method to BatteryUtils
so we could reuse it.
3. Add and update the tests

Bug: 70570352
Test: RunSettingsRoboTests

Change-Id: I6a7248d9d48ee8cb6fc2c18c8c225210d49b6bc9

tests/robotests/src/com/android/settings/fuelgauge/BatteryUtilsTest.java

@@ -20,7 +20,9 @@ import static android.os.BatteryStats.Uid.PROCESS_STATE_FOREGROUND;
 import static android.os.BatteryStats.Uid.PROCESS_STATE_FOREGROUND_SERVICE;
 import static android.os.BatteryStats.Uid.PROCESS_STATE_TOP;
 import static android.os.BatteryStats.Uid.PROCESS_STATE_TOP_SLEEPING;
+
 import static com.google.common.truth.Truth.assertThat;
+
 import static org.mockito.Matchers.any;
 import static org.mockito.Matchers.anyInt;
 import static org.mockito.Matchers.anyLong;
@@ -141,6 +143,7 @@ public class BatteryUtilsTest {
     private BatteryUtils mBatteryUtils;
     private FakeFeatureFactory mFeatureFactory;
     private PowerUsageFeatureProvider mProvider;
+    private List<BatterySipper> mUsageList;
 
     @Before
     public void setUp() {
@@ -194,6 +197,12 @@ public class BatteryUtilsTest {
         mBatteryUtils.mPowerUsageFeatureProvider = mProvider;
         doReturn(0L).when(mBatteryUtils).getForegroundServiceTotalTimeUs(
                 any(BatteryStats.Uid.class), anyLong());
+
+        mUsageList = new ArrayList<>();
+        mUsageList.add(mNormalBatterySipper);
+        mUsageList.add(mScreenBatterySipper);
+        mUsageList.add(mCellBatterySipper);
+        doReturn(mUsageList).when(mBatteryStatsHelper).getUsageList();
     }
 
     @Test
@@ -468,4 +477,28 @@ public class BatteryUtilsTest {
         verify(mBatteryStatsHelper).refreshStats(BatteryStats.STATS_SINCE_CHARGED,
                 mUserManager.getUserProfiles());
     }
+
+    @Test
+    public void testFindBatterySipperByType_findTypeScreen() {
+        BatterySipper sipper = mBatteryUtils.findBatterySipperByType(mUsageList,
+                BatterySipper.DrainType.SCREEN);
+
+        assertThat(sipper).isSameAs(mScreenBatterySipper);
+    }
+
+    @Test
+    public void testFindBatterySipperByType_findTypeApp() {
+        BatterySipper sipper = mBatteryUtils.findBatterySipperByType(mUsageList,
+                BatterySipper.DrainType.APP);
+
+        assertThat(sipper).isSameAs(mNormalBatterySipper);
+    }
+
+    @Test
+    public void testCalculateScreenUsageTime_returnCorrectTime() {
+        mScreenBatterySipper.usageTimeMs = TIME_EXPECTED_FOREGROUND;
+
+        assertThat(mBatteryUtils.calculateScreenUsageTime(mBatteryStatsHelper)).isEqualTo(
+                TIME_EXPECTED_FOREGROUND);
+    }
 }

tests/robotests/src/com/android/settings/fuelgauge/PowerUsageSummaryTest.java

@@ -247,34 +247,6 @@ public class PowerUsageSummaryTest {
         assertThat(mFragment.mShowAllApps).isEqualTo(!isShowApps);
     }
 
-    @Test
-    public void testFindBatterySipperByType_findTypeScreen() {
-        BatterySipper sipper = mFragment.findBatterySipperByType(mUsageList,
-                BatterySipper.DrainType.SCREEN);
-
-        assertThat(sipper).isSameAs(mScreenBatterySipper);
-    }
-
-    @Test
-    public void testFindBatterySipperByType_findTypeApp() {
-        BatterySipper sipper = mFragment.findBatterySipperByType(mUsageList,
-                BatterySipper.DrainType.APP);
-
-        assertThat(sipper).isSameAs(mNormalBatterySipper);
-    }
-
-    @Test
-    public void testUpdateScreenPreference_showCorrectSummary() {
-        doReturn(mScreenBatterySipper).when(mFragment).findBatterySipperByType(any(), any());
-        doReturn(mRealContext).when(mFragment).getContext();
-        final CharSequence expectedSummary = Utils.formatElapsedTime(mRealContext, USAGE_TIME_MS,
-                false);
-
-        mFragment.updateScreenPreference();
-
-        assertThat(mScreenUsagePref.getSubtitle()).isEqualTo(expectedSummary);
-    }
-
     @Test
     public void testUpdateLastFullChargePreference_showCorrectSummary() {
         doReturn(mRealContext).when(mFragment).getContext();
@@ -284,16 +256,6 @@ public class PowerUsageSummaryTest {
         assertThat(mLastFullChargePref.getSubtitle()).isEqualTo("2 hr. ago");
     }
 
-    @Test
-    public void testUpdatePreference_usageListEmpty_shouldNotCrash() {
-        when(mBatteryHelper.getUsageList()).thenReturn(new ArrayList<BatterySipper>());
-        doReturn(STUB_STRING).when(mFragment).getString(anyInt(), any());
-        doReturn(mRealContext).when(mFragment).getContext();
-
-        // Should not crash when update
-        mFragment.updateScreenPreference();
-    }
-
     @Test
     public void testNonIndexableKeys_MatchPreferenceKeys() {
         final Context context = RuntimeEnvironment.application;

tests/robotests/src/com/android/settings/fuelgauge/batterytip/detectors/HighUsageDetectorTest.java

@@ -0,0 +1,94 @@
+/*
+ * Copyright (C) 2017 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.detectors;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.spy;
+
+import android.content.Context;
+import android.os.BatteryStats;
+import android.text.format.DateUtils;
+
+import com.android.internal.os.BatterySipper;
+import com.android.internal.os.BatteryStatsHelper;
+import com.android.settings.TestConfig;
+import com.android.settings.fuelgauge.BatteryInfo;
+import com.android.settings.fuelgauge.BatteryUtils;
+import com.android.settings.fuelgauge.batterytip.BatteryTipPolicy;
+import com.android.settings.testutils.SettingsRobolectricTestRunner;
+
+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 org.robolectric.annotation.Config;
+import org.robolectric.util.ReflectionHelpers;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@RunWith(SettingsRobolectricTestRunner.class)
+@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
+public class HighUsageDetectorTest {
+    private Context mContext;
+    @Mock
+    private BatteryStatsHelper mBatteryStatsHelper;
+    @Mock
+    private BatteryUtils mBatteryUtils;
+    @Mock
+    private BatterySipper mBatterySipper;
+
+    private BatteryTipPolicy mPolicy;
+    private HighUsageDetector mHighUsageDetector;
+    private List<BatterySipper> mUsageList;
+
+    @Before
+    public void setUp() {
+        MockitoAnnotations.initMocks(this);
+
+        mContext = RuntimeEnvironment.application;
+        mPolicy = spy(new BatteryTipPolicy(mContext));
+        mHighUsageDetector = new HighUsageDetector(mContext, mPolicy, mBatteryStatsHelper);
+        mHighUsageDetector.mBatteryUtils = mBatteryUtils;
+
+        mUsageList = new ArrayList<>();
+        mUsageList.add(mBatterySipper);
+    }
+
+    @Test
+    public void testDetect_disabledByPolicy_tipInvisible() {
+        ReflectionHelpers.setField(mPolicy, "highUsageEnabled", false);
+
+        assertThat(mHighUsageDetector.detect().isVisible()).isFalse();
+    }
+
+    @Test
+    public void testDetect_containsHighUsageApp_tipVisible() {
+        doReturn(2 * DateUtils.HOUR_IN_MILLIS).when(mBatteryUtils).calculateScreenUsageTime(
+                mBatteryStatsHelper);
+        doReturn(mUsageList).when(mBatteryStatsHelper).getUsageList();
+        doReturn(DateUtils.HOUR_IN_MILLIS).when(mBatteryUtils).getProcessTimeMs(
+                BatteryUtils.StatusType.FOREGROUND, mBatterySipper.uidObj,
+                BatteryStats.STATS_SINCE_CHARGED);
+
+        assertThat(mHighUsageDetector.detect().isVisible()).isTrue();
+    }
+}