UsageType.USER,
UsageType.IDLE,
UsageType.APP,
- UsageType.UNACCOUNTED};
+ UsageType.UNACCOUNTED,
+ UsageType.OVERCOUNTED};
private BatteryHistoryPreference mHistPref;
private PreferenceGroup mUsageListGroup;
private PowerUsageFeatureProvider mPowerUsageFeatureProvider;
mUsageListGroup.removeAll();
for (int i = 0, size = dataList.size(); i < size; i++) {
final PowerUsageData batteryData = dataList.get(i);
+ if (shouldHide(batteryData)) {
+ continue;
+ }
final PowerGaugePreference pref = new PowerGaugePreference(getPrefContext());
pref.setKey(String.valueOf(batteryData.usageType));
return UsageType.CELL;
} else if (drainType == DrainType.UNACCOUNTED) {
return UsageType.UNACCOUNTED;
+ } else if (drainType == DrainType.OVERCOUNTED) {
+ return UsageType.OVERCOUNTED;
} else if (mPowerUsageFeatureProvider.isTypeSystem(sipper)) {
return UsageType.SYSTEM;
} else if (mPowerUsageFeatureProvider.isTypeService(sipper)) {
}
@VisibleForTesting
+ boolean shouldHide(PowerUsageData powerUsageData) {
+ if (powerUsageData.usageType == UsageType.UNACCOUNTED
+ || powerUsageData.usageType == UsageType.OVERCOUNTED) {
+ return true;
+ }
+
+ return false;
+ }
+
+ @VisibleForTesting
List<PowerUsageData> parsePowerUsageData(BatteryStatsHelper statusHelper) {
final List<BatterySipper> batterySippers = statusHelper.getUsageList();
final Map<Integer, PowerUsageData> batteryDataMap = new HashMap<>();
UsageType.BLUETOOTH,
UsageType.USER,
UsageType.IDLE,
- UsageType.UNACCOUNTED})
+ UsageType.UNACCOUNTED,
+ UsageType.OVERCOUNTED})
public @interface UsageType {
int APP = 0;
int WIFI = 1;
int USER = 6;
int IDLE = 7;
int UNACCOUNTED = 8;
+ int OVERCOUNTED = 9;
}
@StringRes
return R.string.power_idle;
case UsageType.UNACCOUNTED:
return R.string.power_unaccounted;
+ case UsageType.OVERCOUNTED:
+ return R.string.power_overcounted;
case UsageType.APP:
default:
return R.string.power_apps;
|| drainType == DrainType.WIFI
|| drainType == DrainType.SCREEN
|| drainType == DrainType.BLUETOOTH
+ || drainType == DrainType.UNACCOUNTED
+ || drainType == DrainType.OVERCOUNTED
|| (sipper.totalPowerMah * SECONDS_IN_HOUR) < MIN_POWER_THRESHOLD_MILLI_AMP
|| mPowerFeatureProvider.isTypeService(sipper)
|| mPowerFeatureProvider.isTypeSystem(sipper);
final BatterySipper sipper = sippers.get(i);
if (shouldHideSipper(sipper)) {
sippers.remove(i);
- totalPowerMah += sipper.totalPowerMah;
+ if (sipper.drainType != DrainType.OVERCOUNTED
+ && sipper.drainType != DrainType.UNACCOUNTED) {
+ // Don't add it if it is overcounted or unaccounted
+ totalPowerMah += sipper.totalPowerMah;
+ }
}
}
assertThat(usageTypeSet).asList().containsExactly(UsageType.APP, UsageType.WIFI,
UsageType.CELL, UsageType.BLUETOOTH, UsageType.IDLE, UsageType.SERVICE,
- UsageType.USER, UsageType.SYSTEM, UsageType.UNACCOUNTED);
+ UsageType.USER, UsageType.SYSTEM, UsageType.UNACCOUNTED, UsageType.OVERCOUNTED);
}
@Test
assertThat(dataList.get(i - 1).totalPowerMah).isAtLeast(dataList.get(i).totalPowerMah);
}
}
+
+ @Test
+ public void testShouldHide_typeUnAccounted_returnTrue() {
+ mPowerUsageData.usageType = UsageType.UNACCOUNTED;
+
+ assertThat(mPowerUsageAdvanced.shouldHide(mPowerUsageData)).isTrue();
+ }
+
+
+ @Test
+ public void testShouldHide_typeOverCounted_returnTrue() {
+ mPowerUsageData.usageType = UsageType.OVERCOUNTED;
+
+ assertThat(mPowerUsageAdvanced.shouldHide(mPowerUsageData)).isTrue();
+ }
+
+
+ @Test
+ public void testShouldHide_typeNormal_returnFalse() {
+ mPowerUsageData.usageType = UsageType.APP;
+
+ assertThat(mPowerUsageAdvanced.shouldHide(mPowerUsageData)).isFalse();
+ }
}
private static final double TOTAL_POWER = 200;
private static final double BATTERY_SCREEN_USAGE = 300;
private static final double BATTERY_SYSTEM_USAGE = 600;
+ private static final double BATTERY_OVERCOUNTED_USAGE = 500;
private static final double PRECISION = 0.001;
private static final double POWER_USAGE_PERCENTAGE = 50;
private static final Intent ADDITIONAL_BATTERY_INFO_INTENT =
@Mock
private BatterySipper mScreenBatterySipper;
@Mock
+ private BatterySipper mOvercountedBatterySipper;
+ @Mock
private BatterySipper mSystemBatterySipper;
@Mock
private BatterySipper mCellBatterySipper;
mSystemBatterySipper.totalPowerMah = BATTERY_SYSTEM_USAGE;
when(mSystemBatterySipper.getUid()).thenReturn(Process.SYSTEM_UID);
+ mOvercountedBatterySipper.drainType = BatterySipper.DrainType.OVERCOUNTED;
+ mOvercountedBatterySipper.totalPowerMah = BATTERY_OVERCOUNTED_USAGE;
+
mUsageList = new ArrayList<>();
mUsageList.add(mNormalBatterySipper);
mUsageList.add(mScreenBatterySipper);
sippers.add(mNormalBatterySipper);
sippers.add(mScreenBatterySipper);
sippers.add(mSystemBatterySipper);
+ sippers.add(mOvercountedBatterySipper);
when(mFeatureFactory.powerUsageFeatureProvider.isTypeSystem(mSystemBatterySipper))
.thenReturn(true);
}
@Test
+ public void testShouldHideSipper_TypeUnAccounted_ReturnTrue() {
+ mNormalBatterySipper.drainType = BatterySipper.DrainType.UNACCOUNTED;
+ assertThat(mFragment.shouldHideSipper(mNormalBatterySipper)).isTrue();
+ }
+
+ @Test
+ public void testShouldHideSipper_TypeOverCounted_ReturnTrue() {
+ mNormalBatterySipper.drainType = BatterySipper.DrainType.OVERCOUNTED;
+ assertThat(mFragment.shouldHideSipper(mNormalBatterySipper)).isTrue();
+ }
+
+ @Test
public void testShouldHideSipper_typeWifi_returnTrue() {
mNormalBatterySipper.drainType = BatterySipper.DrainType.WIFI;
assertThat(mFragment.shouldHideSipper(mNormalBatterySipper)).isTrue();