Merge "Distribute the misc among all the apps" into oc-dev

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

@@ -128,9 +128,8 @@ public class BatteryUtils {
             final BatterySipper sipper = sippers.get(i);
             if (shouldHideSipper(sipper)) {
                 sippers.remove(i);
-                if (sipper.drainType != BatterySipper.DrainType.OVERCOUNTED
+                if (sipper.drainType != BatterySipper.DrainType.OVERCOUNTED) {
-                        && sipper.drainType != BatterySipper.DrainType.UNACCOUNTED) {
+                    // Don't add it if it is overcounted
-                    // Don't add it if it is overcounted or unaccounted
                     totalPowerMah += sipper.totalPowerMah;
                 }
             }

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

@@ -69,8 +69,7 @@ public class PowerUsageAdvanced extends PowerUsageBase {
             UsageType.UNACCOUNTED,
             UsageType.OVERCOUNTED};
 
-    @VisibleForTesting
+    private BatteryUtils mBatteryUtils;
-    BatteryUtils mBatteryUtils;
     private BatteryHistoryPreference mHistPref;
     private PreferenceGroup mUsageListGroup;
     private PowerUsageFeatureProvider mPowerUsageFeatureProvider;
@@ -258,8 +257,10 @@ public class PowerUsageAdvanced extends PowerUsageBase {
         final List<PowerUsageData> batteryDataList = new ArrayList<>(batteryDataMap.values());
         final int dischargeAmount = statusHelper.getStats().getDischargeAmount(STATUS_TYPE);
         final double totalPower = statusHelper.getTotalPower();
+        final double hiddenPower = calculateHiddenPower(batteryDataList);
         for (final PowerUsageData usageData : batteryDataList) {
-            usageData.percentage = (usageData.totalPowerMah / totalPower) * dischargeAmount;
+            usageData.percentage = mBatteryUtils.calculateBatteryPercent(usageData.totalPowerMah,
+                    totalPower, hiddenPower, dischargeAmount);
             updateUsageDataSummary(usageData, totalPower, dischargeAmount);
         }
 
@@ -269,6 +270,17 @@ public class PowerUsageAdvanced extends PowerUsageBase {
         return batteryDataList;
     }
 
+    @VisibleForTesting
+    double calculateHiddenPower(List<PowerUsageData> batteryDataList) {
+        for (final PowerUsageData usageData : batteryDataList) {
+            if (usageData.usageType == UsageType.UNACCOUNTED) {
+                return usageData.totalPowerMah;
+            }
+        }
+
+        return 0;
+    }
+
     @VisibleForTesting
     void updateUsageDataSummary(PowerUsageData usageData, double totalPower, int dischargeAmount) {
         if (shouldHideSummary(usageData)) {
@@ -322,6 +334,10 @@ public class PowerUsageAdvanced extends PowerUsageBase {
     void setUserManager(UserManager userManager) {
         mUserManager = userManager;
     }
+    @VisibleForTesting
+    void setBatteryUtils(BatteryUtils batteryUtils) {
+        mBatteryUtils = batteryUtils;
+    }
 
     /**
      * Class that contains data used in {@link PowerGaugePreference}.

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

@@ -70,6 +70,7 @@ public class BatteryUtilsTest {
     private static final double BATTERY_SCREEN_USAGE = 300;
     private static final double BATTERY_SYSTEM_USAGE = 600;
     private static final double BATTERY_OVERACCOUNTED_USAGE = 500;
+    private static final double BATTERY_UNACCOUNTED_USAGE = 700;
     private static final double TOTAL_BATTERY_USAGE = 1000;
     private static final double HIDDEN_USAGE = 200;
     private static final int DISCHARGE_AMOUNT = 80;
@@ -85,6 +86,8 @@ public class BatteryUtilsTest {
     @Mock
     private BatterySipper mOvercountedBatterySipper;
     @Mock
+    private BatterySipper mUnaccountedBatterySipper;
+    @Mock
     private BatterySipper mSystemBatterySipper;
     @Mock
     private BatterySipper mCellBatterySipper;
@@ -126,6 +129,9 @@ public class BatteryUtilsTest {
         mOvercountedBatterySipper.drainType = BatterySipper.DrainType.OVERCOUNTED;
         mOvercountedBatterySipper.totalPowerMah = BATTERY_OVERACCOUNTED_USAGE;
 
+        mUnaccountedBatterySipper.drainType = BatterySipper.DrainType.UNACCOUNTED;
+        mUnaccountedBatterySipper.totalPowerMah = BATTERY_UNACCOUNTED_USAGE;
+
         mBatteryUtils = BatteryUtils.getInstance(RuntimeEnvironment.application);
         mBatteryUtils.mPowerUsageFeatureProvider = mProvider;
 
@@ -171,12 +177,14 @@ public class BatteryUtilsTest {
         sippers.add(mScreenBatterySipper);
         sippers.add(mSystemBatterySipper);
         sippers.add(mOvercountedBatterySipper);
+        sippers.add(mUnaccountedBatterySipper);
         when(mProvider.isTypeSystem(mSystemBatterySipper))
                 .thenReturn(true);
 
         final double totalUsage = mBatteryUtils.removeHiddenBatterySippers(sippers);
         assertThat(sippers).containsExactly(mNormalBatterySipper);
-        assertThat(totalUsage).isWithin(PRECISION).of(BATTERY_SCREEN_USAGE + BATTERY_SYSTEM_USAGE);
+        assertThat(totalUsage).isWithin(PRECISION).of(
+                BATTERY_SCREEN_USAGE + BATTERY_SYSTEM_USAGE + BATTERY_UNACCOUNTED_USAGE);
     }
 
     @Test

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

@@ -111,7 +111,7 @@ public class PowerUsageAdvancedTest {
         mPowerUsageAdvanced.setPackageManager(mPackageManager);
         mPowerUsageAdvanced.setPowerUsageFeatureProvider(mPowerUsageFeatureProvider);
         mPowerUsageAdvanced.setUserManager(mUserManager);
-        mPowerUsageAdvanced.mBatteryUtils = spy(new BatteryUtils(mShadowContext));
+        mPowerUsageAdvanced.setBatteryUtils(BatteryUtils.getInstance(mShadowContext));
 
         mPowerUsageData = new PowerUsageData(UsageType.APP);
         mMaxBatterySipper.totalPowerMah = TYPE_BLUETOOTH_USAGE;
@@ -299,4 +299,16 @@ public class PowerUsageAdvancedTest {
         assertThat(mPowerUsageAdvanced.shouldShowBatterySipper(mNormalBatterySipper)).isTrue();
     }
 
+    @Test
+    public void testCalculateHiddenPower_returnCorrectPower() {
+        List<PowerUsageData> powerUsageDataList = new ArrayList<>();
+        final double unaccountedPower = 100;
+        final double normalPower = 150;
+        powerUsageDataList.add(new PowerUsageData(UsageType.UNACCOUNTED, unaccountedPower));
+        powerUsageDataList.add(new PowerUsageData(UsageType.APP, normalPower));
+        powerUsageDataList.add(new PowerUsageData(UsageType.CELL, normalPower));
+
+        assertThat(mPowerUsageAdvanced.calculateHiddenPower(powerUsageDataList)).isWithin(
+                PRECISION).of(unaccountedPower);
+    }
 }