PawletOS/app_Settings
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Populate new fields foreground_service_usage_time_in_ms,

Browse Source 
foreground_usage_consume_power, foreground_service_usage_consume_power,
background_usage_consume_power and cached_usage_consume_power into
database and pass them to UI.

Test: make RunSettingsRoboTests + manual
Bug: 256123455
Bug: 258124768
Change-Id: Ic46032f67eff5898f9d4182c517bbebe478eca01
This commit is contained in:
Kuan Wang
2022-11-21 10:41:02 +08:00
parent a6a7e029d7
commit 53a761f55b
14 changed files with 707 additions and 713 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/com/android/settings/fuelgauge/batteryusage/BatteryChartPreferenceController.java
View File

@@ -629,6 +629,7 @@ public class BatteryChartPreferenceController extends AbstractPreferenceControll
PowerGaugePreference preference, BatteryDiffEntry entry) { PowerGaugePreference preference, BatteryDiffEntry entry) {
final long foregroundUsageTimeInMs = entry.mForegroundUsageTimeInMs; final long foregroundUsageTimeInMs = entry.mForegroundUsageTimeInMs;
final long backgroundUsageTimeInMs = entry.mBackgroundUsageTimeInMs; final long backgroundUsageTimeInMs = entry.mBackgroundUsageTimeInMs;
// TODO: update this value after the new API for foreground service is completed.
final long totalUsageTimeInMs = foregroundUsageTimeInMs + backgroundUsageTimeInMs; final long totalUsageTimeInMs = foregroundUsageTimeInMs + backgroundUsageTimeInMs;
String usageTimeSummary = null; String usageTimeSummary = null;
// Not shows summary for some system components without usage time. // Not shows summary for some system components without usage time.

35
src/com/android/settings/fuelgauge/batteryusage/BatteryDiffEntry.java
View File

@@ -52,8 +52,13 @@ public class BatteryDiffEntry {
(a, b) -> Double.compare(b.getPercentOfTotal(), a.getPercentOfTotal()); (a, b) -> Double.compare(b.getPercentOfTotal(), a.getPercentOfTotal());
public long mForegroundUsageTimeInMs; public long mForegroundUsageTimeInMs;
public long mForegroundServiceUsageTimeInMs;
public long mBackgroundUsageTimeInMs; public long mBackgroundUsageTimeInMs;
public double mConsumePower; public double mConsumePower;
public double mForegroundUsageConsumePower;
public double mForegroundServiceUsageConsumePower;
public double mBackgroundUsageConsumePower;
public double mCachedUsageConsumePower;
// A BatteryHistEntry corresponding to this diff usage data. // A BatteryHistEntry corresponding to this diff usage data.
public final BatteryHistEntry mBatteryHistEntry; public final BatteryHistEntry mBatteryHistEntry;
@@ -78,12 +83,22 @@ public class BatteryDiffEntry {
public BatteryDiffEntry( public BatteryDiffEntry(
Context context, Context context,
long foregroundUsageTimeInMs, long foregroundUsageTimeInMs,
long foregroundServiceUsageTimeInMs,
long backgroundUsageTimeInMs, long backgroundUsageTimeInMs,
double consumePower, double consumePower,
double foregroundUsageConsumePower,
double foregroundServiceUsageConsumePower,
double backgroundUsageConsumePower,
double cachedUsageConsumePower,
BatteryHistEntry batteryHistEntry) { BatteryHistEntry batteryHistEntry) {
mContext = context; mContext = context;
mConsumePower = consumePower; mConsumePower = consumePower;
mForegroundUsageConsumePower = foregroundUsageConsumePower;
mForegroundServiceUsageConsumePower = foregroundServiceUsageConsumePower;
mBackgroundUsageConsumePower = backgroundUsageConsumePower;
mCachedUsageConsumePower = cachedUsageConsumePower;
mForegroundUsageTimeInMs = foregroundUsageTimeInMs; mForegroundUsageTimeInMs = foregroundUsageTimeInMs;
mForegroundServiceUsageTimeInMs = foregroundServiceUsageTimeInMs;
mBackgroundUsageTimeInMs = backgroundUsageTimeInMs; mBackgroundUsageTimeInMs = backgroundUsageTimeInMs;
mBatteryHistEntry = batteryHistEntry; mBatteryHistEntry = batteryHistEntry;
mUserManager = context.getSystemService(UserManager.class); mUserManager = context.getSystemService(UserManager.class);
@@ -106,8 +121,13 @@ public class BatteryDiffEntry {
return new BatteryDiffEntry( return new BatteryDiffEntry(
this.mContext, this.mContext,
this.mForegroundUsageTimeInMs, this.mForegroundUsageTimeInMs,
this.mForegroundServiceUsageTimeInMs,
this.mBackgroundUsageTimeInMs, this.mBackgroundUsageTimeInMs,
this.mConsumePower, this.mConsumePower,
this.mForegroundUsageConsumePower,
this.mForegroundServiceUsageConsumePower,
this.mBackgroundUsageConsumePower,
this.mCachedUsageConsumePower,
this.mBatteryHistEntry /*same instance*/); this.mBatteryHistEntry /*same instance*/);
} }
@@ -361,10 +381,19 @@ public class BatteryDiffEntry {
mAppLabel, mValidForRestriction)) mAppLabel, mValidForRestriction))
.append(String.format("\n\tconsume=%.2f%% %f/%f", .append(String.format("\n\tconsume=%.2f%% %f/%f",
mPercentOfTotal, mConsumePower, mTotalConsumePower)) mPercentOfTotal, mConsumePower, mTotalConsumePower))
.append(String.format("\n\tforeground:%s background:%s", .append(String.format("\n\tconsume power= foreground:%f foregroundService:%f",
StringUtil.formatElapsedTime(mContext, mForegroundUsageTimeInMs, mForegroundUsageConsumePower, mForegroundServiceUsageConsumePower))
.append(String.format("\n\tconsume power= background:%f cached:%f",
mBackgroundUsageConsumePower, mCachedUsageConsumePower))
.append(String.format("\n\ttime= foreground:%s foregroundService:%s background:%s",
StringUtil.formatElapsedTime(mContext, (double) mForegroundUsageTimeInMs,
/*withSeconds=*/ true, /*collapseTimeUnit=*/ false), /*withSeconds=*/ true, /*collapseTimeUnit=*/ false),
StringUtil.formatElapsedTime(mContext, mBackgroundUsageTimeInMs, StringUtil.formatElapsedTime(
mContext,
(double) mForegroundServiceUsageTimeInMs,
/*withSeconds=*/ true,
/*collapseTimeUnit=*/ false),
StringUtil.formatElapsedTime(mContext, (double) mBackgroundUsageTimeInMs,
/*withSeconds=*/ true, /*collapseTimeUnit=*/ false))) /*withSeconds=*/ true, /*collapseTimeUnit=*/ false)))
.append(String.format("\n\tpackage:%s|%s uid:%d userId:%d", .append(String.format("\n\tpackage:%s|%s uid:%d userId:%d",
mBatteryHistEntry.mPackageName, getPackageName(), mBatteryHistEntry.mPackageName, getPackageName(),

116
src/com/android/settings/fuelgauge/batteryusage/BatteryEntry.java
View File

@@ -26,6 +26,7 @@ import android.content.pm.PackageManager.NameNotFoundException;
import android.content.pm.UserInfo; import android.content.pm.UserInfo;
import android.graphics.drawable.Drawable; import android.graphics.drawable.Drawable;
import android.os.BatteryConsumer; import android.os.BatteryConsumer;
import android.os.BatteryConsumer.Dimensions;
import android.os.Process; import android.os.Process;
import android.os.RemoteException; import android.os.RemoteException;
import android.os.UidBatteryConsumer; import android.os.UidBatteryConsumer;
@@ -39,7 +40,6 @@ import com.android.settings.R;
import com.android.settings.fuelgauge.BatteryUtils; import com.android.settings.fuelgauge.BatteryUtils;
import com.android.settingslib.Utils; import com.android.settingslib.Utils;
import java.util.ArrayList;
import java.util.Comparator; import java.util.Comparator;
import java.util.HashMap; import java.util.HashMap;
import java.util.Locale; import java.util.Locale;
@@ -73,9 +73,24 @@ public class BatteryEntry {
private static final String TAG = "BatteryEntry"; private static final String TAG = "BatteryEntry";
private static final String PACKAGE_SYSTEM = "android"; private static final String PACKAGE_SYSTEM = "android";
static final HashMap<String, UidToDetail> sUidCache = new HashMap<>(); static final int BATTERY_USAGE_INDEX_FOREGROUND = 0;
static final int BATTERY_USAGE_INDEX_FOREGROUND_SERVICE = 1;
static final int BATTERY_USAGE_INDEX_BACKGROUND = 2;
static final int BATTERY_USAGE_INDEX_CACHED = 3;
static final ArrayList<BatteryEntry> sRequestQueue = new ArrayList<BatteryEntry>(); static final Dimensions[] BATTERY_DIMENSIONS = new Dimensions[] {
new Dimensions(
BatteryConsumer.POWER_COMPONENT_ANY, BatteryConsumer.PROCESS_STATE_FOREGROUND),
new Dimensions(
BatteryConsumer.POWER_COMPONENT_ANY,
BatteryConsumer.PROCESS_STATE_FOREGROUND_SERVICE),
new Dimensions(
BatteryConsumer.POWER_COMPONENT_ANY, BatteryConsumer.PROCESS_STATE_BACKGROUND),
new Dimensions(
BatteryConsumer.POWER_COMPONENT_ANY, BatteryConsumer.PROCESS_STATE_CACHED),
};
static final HashMap<String, UidToDetail> sUidCache = new HashMap<>();
static Locale sCurrentLocale = null; static Locale sCurrentLocale = null;
@@ -97,6 +112,7 @@ public class BatteryEntry {
private final int mPowerComponentId; private final int mPowerComponentId;
private long mUsageDurationMs; private long mUsageDurationMs;
private long mTimeInForegroundMs; private long mTimeInForegroundMs;
private long mTimeInForegroundServiceMs;
private long mTimeInBackgroundMs; private long mTimeInBackgroundMs;
public String mName; public String mName;
@@ -105,6 +121,10 @@ public class BatteryEntry {
public double mPercent; public double mPercent;
private String mDefaultPackageName; private String mDefaultPackageName;
private double mConsumedPower; private double mConsumedPower;
private double mConsumedPowerInForeground;
private double mConsumedPowerInForegroundService;
private double mConsumedPowerInBackground;
private double mConsumedPowerInCached;
static class UidToDetail { static class UidToDetail {
String mName; String mName;
@@ -156,8 +176,19 @@ public class BatteryEntry {
getQuickNameIconForUid(uid, packages, loadDataInBackground); getQuickNameIconForUid(uid, packages, loadDataInBackground);
mTimeInForegroundMs = mTimeInForegroundMs =
uidBatteryConsumer.getTimeInStateMs(UidBatteryConsumer.STATE_FOREGROUND); uidBatteryConsumer.getTimeInStateMs(UidBatteryConsumer.STATE_FOREGROUND);
//TODO: update this to the correct API after the new API is completed.
mTimeInForegroundServiceMs =
uidBatteryConsumer.getTimeInStateMs(UidBatteryConsumer.STATE_FOREGROUND);
mTimeInBackgroundMs = mTimeInBackgroundMs =
uidBatteryConsumer.getTimeInStateMs(UidBatteryConsumer.STATE_BACKGROUND); uidBatteryConsumer.getTimeInStateMs(UidBatteryConsumer.STATE_BACKGROUND);
mConsumedPowerInForeground = safeGetConsumedPower(
uidBatteryConsumer, BATTERY_DIMENSIONS[BATTERY_USAGE_INDEX_FOREGROUND]);
mConsumedPowerInForegroundService = safeGetConsumedPower(
uidBatteryConsumer, BATTERY_DIMENSIONS[BATTERY_USAGE_INDEX_FOREGROUND_SERVICE]);
mConsumedPowerInBackground = safeGetConsumedPower(
uidBatteryConsumer, BATTERY_DIMENSIONS[BATTERY_USAGE_INDEX_BACKGROUND]);
mConsumedPowerInCached = safeGetConsumedPower(
uidBatteryConsumer, BATTERY_DIMENSIONS[BATTERY_USAGE_INDEX_CACHED]);
} else if (batteryConsumer instanceof UserBatteryConsumer) { } else if (batteryConsumer instanceof UserBatteryConsumer) {
mUid = Process.INVALID_UID; mUid = Process.INVALID_UID;
mConsumerType = ConvertUtils.CONSUMER_TYPE_USER_BATTERY; mConsumerType = ConvertUtils.CONSUMER_TYPE_USER_BATTERY;
@@ -396,7 +427,7 @@ public class BatteryEntry {
return mUid; return mUid;
} }
/** Returns foreground foreground time/ms that is attributed to this entry. */ /** Returns foreground time/ms that is attributed to this entry. */
public long getTimeInForegroundMs() { public long getTimeInForegroundMs() {
if (mBatteryConsumer instanceof UidBatteryConsumer) { if (mBatteryConsumer instanceof UidBatteryConsumer) {
return mTimeInForegroundMs; return mTimeInForegroundMs;
@@ -405,6 +436,15 @@ public class BatteryEntry {
} }
} }
/** Returns foreground service time/ms that is attributed to this entry. */
public long getTimeInForegroundServiceMs() {
if (mBatteryConsumer instanceof UidBatteryConsumer) {
return mTimeInForegroundServiceMs;
} else {
return 0;
}
}
/** Returns background activity time/ms that is attributed to this entry. */ /** Returns background activity time/ms that is attributed to this entry. */
public long getTimeInBackgroundMs() { public long getTimeInBackgroundMs() {
if (mBatteryConsumer instanceof UidBatteryConsumer) { if (mBatteryConsumer instanceof UidBatteryConsumer) {
@@ -421,6 +461,53 @@ public class BatteryEntry {
return mConsumedPower; return mConsumedPower;
} }
/**
* Returns amount of power (in milli-amp-hours) used in foreground that is attributed to this
* entry.
*/
public double getConsumedPowerInForeground() {
if (mBatteryConsumer instanceof UidBatteryConsumer) {
return mConsumedPowerInForeground;
} else {
return 0;
}
}
/**
* Returns amount of power (in milli-amp-hours) used in foreground service that is attributed to
* this entry.
*/
public double getConsumedPowerInForegroundService() {
if (mBatteryConsumer instanceof UidBatteryConsumer) {
return mConsumedPowerInForegroundService;
} else {
return 0;
}
}
/**
* Returns amount of power (in milli-amp-hours) used in background that is attributed to this
* entry.
*/
public double getConsumedPowerInBackground() {
if (mBatteryConsumer instanceof UidBatteryConsumer) {
return mConsumedPowerInBackground;
} else {
return 0;
}
}
/**
* Returns amount of power (in milli-amp-hours) used in cached that is attributed to this entry.
*/
public double getConsumedPowerInCached() {
if (mBatteryConsumer instanceof UidBatteryConsumer) {
return mConsumedPowerInCached;
} else {
return 0;
}
}
/** /**
* Adds the consumed power of the supplied BatteryConsumer to this entry. Also * Adds the consumed power of the supplied BatteryConsumer to this entry. Also
* uses its package with highest drain, if necessary. * uses its package with highest drain, if necessary.
@@ -431,8 +518,19 @@ public class BatteryEntry {
UidBatteryConsumer uidBatteryConsumer = (UidBatteryConsumer) batteryConsumer; UidBatteryConsumer uidBatteryConsumer = (UidBatteryConsumer) batteryConsumer;
mTimeInForegroundMs += uidBatteryConsumer.getTimeInStateMs( mTimeInForegroundMs += uidBatteryConsumer.getTimeInStateMs(
UidBatteryConsumer.STATE_FOREGROUND); UidBatteryConsumer.STATE_FOREGROUND);
//TODO: update this to the correct API after the new API is completed.
mTimeInForegroundServiceMs += uidBatteryConsumer.getTimeInStateMs(
UidBatteryConsumer.STATE_FOREGROUND);
mTimeInBackgroundMs += uidBatteryConsumer.getTimeInStateMs( mTimeInBackgroundMs += uidBatteryConsumer.getTimeInStateMs(
UidBatteryConsumer.STATE_BACKGROUND); UidBatteryConsumer.STATE_BACKGROUND);
mConsumedPowerInForeground += safeGetConsumedPower(
uidBatteryConsumer, BATTERY_DIMENSIONS[BATTERY_USAGE_INDEX_FOREGROUND]);
mConsumedPowerInForegroundService += safeGetConsumedPower(
uidBatteryConsumer, BATTERY_DIMENSIONS[BATTERY_USAGE_INDEX_FOREGROUND_SERVICE]);
mConsumedPowerInBackground += safeGetConsumedPower(
uidBatteryConsumer, BATTERY_DIMENSIONS[BATTERY_USAGE_INDEX_BACKGROUND]);
mConsumedPowerInCached += safeGetConsumedPower(
uidBatteryConsumer, BATTERY_DIMENSIONS[BATTERY_USAGE_INDEX_CACHED]);
if (mDefaultPackageName == null) { if (mDefaultPackageName == null) {
mDefaultPackageName = uidBatteryConsumer.getPackageWithHighestDrain(); mDefaultPackageName = uidBatteryConsumer.getPackageWithHighestDrain();
} }
@@ -533,4 +631,14 @@ public class BatteryEntry {
public static boolean isSystemUid(int uid) { public static boolean isSystemUid(int uid) {
return uid == Process.SYSTEM_UID; return uid == Process.SYSTEM_UID;
} }
private static double safeGetConsumedPower(
final UidBatteryConsumer uidBatteryConsumer, final Dimensions dimension) {
try {
return uidBatteryConsumer.getConsumedPower(dimension);
} catch (IllegalArgumentException e) {
Log.e(TAG, "safeGetConsumedPower failed:" + e);
return 0.0d;
}
}
} }

78
src/com/android/settings/fuelgauge/batteryusage/BatteryHistEntry.java
View File

@@ -50,8 +50,13 @@ public class BatteryHistEntry {
// Records the battery usage relative information. // Records the battery usage relative information.
public final double mTotalPower; public final double mTotalPower;
public final double mConsumePower; public final double mConsumePower;
public final double mForegroundUsageConsumePower;
public final double mForegroundServiceUsageConsumePower;
public final double mBackgroundUsageConsumePower;
public final double mCachedUsageConsumePower;
public final double mPercentOfTotal; public final double mPercentOfTotal;
public final long mForegroundUsageTimeInMs; public final long mForegroundUsageTimeInMs;
public final long mForegroundServiceUsageTimeInMs;
public final long mBackgroundUsageTimeInMs; public final long mBackgroundUsageTimeInMs;
@BatteryConsumer.PowerComponent @BatteryConsumer.PowerComponent
public final int mDrainType; public final int mDrainType;
@@ -79,8 +84,14 @@ public class BatteryHistEntry {
mZoneId = batteryInformation.getZoneId(); mZoneId = batteryInformation.getZoneId();
mTotalPower = batteryInformation.getTotalPower(); mTotalPower = batteryInformation.getTotalPower();
mConsumePower = batteryInformation.getConsumePower(); mConsumePower = batteryInformation.getConsumePower();
mForegroundUsageConsumePower = batteryInformation.getForegroundUsageConsumePower();
mForegroundServiceUsageConsumePower =
batteryInformation.getForegroundServiceUsageConsumePower();
mBackgroundUsageConsumePower = batteryInformation.getBackgroundUsageConsumePower();
mCachedUsageConsumePower = batteryInformation.getCachedUsageConsumePower();
mPercentOfTotal = batteryInformation.getPercentOfTotal(); mPercentOfTotal = batteryInformation.getPercentOfTotal();
mForegroundUsageTimeInMs = batteryInformation.getForegroundUsageTimeInMs(); mForegroundUsageTimeInMs = batteryInformation.getForegroundUsageTimeInMs();
mForegroundServiceUsageTimeInMs = batteryInformation.getForegroundServiceUsageTimeInMs();
mBackgroundUsageTimeInMs = batteryInformation.getBackgroundUsageTimeInMs(); mBackgroundUsageTimeInMs = batteryInformation.getBackgroundUsageTimeInMs();
mDrainType = batteryInformation.getDrainType(); mDrainType = batteryInformation.getDrainType();
final DeviceBatteryState deviceBatteryState = batteryInformation.getDeviceBatteryState(); final DeviceBatteryState deviceBatteryState = batteryInformation.getDeviceBatteryState();
@@ -103,8 +114,14 @@ public class BatteryHistEntry {
mZoneId = batteryInformation.getZoneId(); mZoneId = batteryInformation.getZoneId();
mTotalPower = batteryInformation.getTotalPower(); mTotalPower = batteryInformation.getTotalPower();
mConsumePower = batteryInformation.getConsumePower(); mConsumePower = batteryInformation.getConsumePower();
mForegroundUsageConsumePower = batteryInformation.getForegroundUsageConsumePower();
mForegroundServiceUsageConsumePower =
batteryInformation.getForegroundServiceUsageConsumePower();
mBackgroundUsageConsumePower = batteryInformation.getBackgroundUsageConsumePower();
mCachedUsageConsumePower = batteryInformation.getCachedUsageConsumePower();
mPercentOfTotal = batteryInformation.getPercentOfTotal(); mPercentOfTotal = batteryInformation.getPercentOfTotal();
mForegroundUsageTimeInMs = batteryInformation.getForegroundUsageTimeInMs(); mForegroundUsageTimeInMs = batteryInformation.getForegroundUsageTimeInMs();
mForegroundServiceUsageTimeInMs = batteryInformation.getForegroundServiceUsageTimeInMs();
mBackgroundUsageTimeInMs = batteryInformation.getBackgroundUsageTimeInMs(); mBackgroundUsageTimeInMs = batteryInformation.getBackgroundUsageTimeInMs();
mDrainType = batteryInformation.getDrainType(); mDrainType = batteryInformation.getDrainType();
final DeviceBatteryState deviceBatteryState = batteryInformation.getDeviceBatteryState(); final DeviceBatteryState deviceBatteryState = batteryInformation.getDeviceBatteryState();
@@ -119,7 +136,12 @@ public class BatteryHistEntry {
long timestamp, long timestamp,
double totalPower, double totalPower,
double consumePower, double consumePower,
double foregroundUsageConsumePower,
double foregroundServiceUsageConsumePower,
double backgroundUsageConsumePower,
double cachedUsageConsumePower,
long foregroundUsageTimeInMs, long foregroundUsageTimeInMs,
long foregroundServiceUsageTimeInMs,
long backgroundUsageTimeInMs, long backgroundUsageTimeInMs,
int batteryLevel) { int batteryLevel) {
mUid = fromEntry.mUid; mUid = fromEntry.mUid;
@@ -132,8 +154,13 @@ public class BatteryHistEntry {
mZoneId = fromEntry.mZoneId; mZoneId = fromEntry.mZoneId;
mTotalPower = totalPower; mTotalPower = totalPower;
mConsumePower = consumePower; mConsumePower = consumePower;
mForegroundUsageConsumePower = foregroundUsageConsumePower;
mForegroundServiceUsageConsumePower = foregroundServiceUsageConsumePower;
mBackgroundUsageConsumePower = backgroundUsageConsumePower;
mCachedUsageConsumePower = cachedUsageConsumePower;
mPercentOfTotal = fromEntry.mPercentOfTotal; mPercentOfTotal = fromEntry.mPercentOfTotal;
mForegroundUsageTimeInMs = foregroundUsageTimeInMs; mForegroundUsageTimeInMs = foregroundUsageTimeInMs;
mForegroundServiceUsageTimeInMs = foregroundServiceUsageTimeInMs;
mBackgroundUsageTimeInMs = backgroundUsageTimeInMs; mBackgroundUsageTimeInMs = backgroundUsageTimeInMs;
mDrainType = fromEntry.mDrainType; mDrainType = fromEntry.mDrainType;
mConsumerType = fromEntry.mConsumerType; mConsumerType = fromEntry.mConsumerType;
@@ -190,9 +217,15 @@ public class BatteryHistEntry {
mPackageName, mAppLabel, mUid, mUserId, mIsHidden)) mPackageName, mAppLabel, mUid, mUserId, mIsHidden))
.append(String.format("\n\ttimestamp=%s|zoneId=%s|bootTimestamp=%d", .append(String.format("\n\ttimestamp=%s|zoneId=%s|bootTimestamp=%d",
recordAtDateTime, mZoneId, Duration.ofMillis(mBootTimestamp).getSeconds())) recordAtDateTime, mZoneId, Duration.ofMillis(mBootTimestamp).getSeconds()))
.append(String.format("\n\tusage=%f|total=%f|consume=%f|elapsedTime=%d|%d", .append(String.format("\n\tusage=%f|total=%f|consume=%f",
mPercentOfTotal, mTotalPower, mConsumePower, mPercentOfTotal, mTotalPower, mConsumePower))
.append(String.format("\n\tforeground=%f|foregroundService=%f",
mForegroundUsageConsumePower, mForegroundServiceUsageConsumePower))
.append(String.format("\n\tbackground=%f|cached=%f",
mBackgroundUsageConsumePower, mCachedUsageConsumePower))
.append(String.format("\n\telapsedTime=%d|%d|%d",
Duration.ofMillis(mForegroundUsageTimeInMs).getSeconds(), Duration.ofMillis(mForegroundUsageTimeInMs).getSeconds(),
Duration.ofMillis(mForegroundServiceUsageTimeInMs).getSeconds(),
Duration.ofMillis(mBackgroundUsageTimeInMs).getSeconds())) Duration.ofMillis(mBackgroundUsageTimeInMs).getSeconds()))
.append(String.format("\n\tdrainType=%d|consumerType=%d", .append(String.format("\n\tdrainType=%d|consumerType=%d",
mDrainType, mConsumerType)) mDrainType, mConsumerType))
@@ -267,17 +300,45 @@ public class BatteryHistEntry {
lowerHistEntry == null ? 0 : lowerHistEntry.mConsumePower, lowerHistEntry == null ? 0 : lowerHistEntry.mConsumePower,
upperHistEntry.mConsumePower, upperHistEntry.mConsumePower,
ratio); ratio);
final double foregroundUsageConsumePower = interpolate(
lowerHistEntry == null ? 0 : lowerHistEntry.mForegroundUsageConsumePower,
upperHistEntry.mForegroundUsageConsumePower,
ratio);
final double foregroundServiceUsageConsumePower = interpolate(
lowerHistEntry == null ? 0 : lowerHistEntry.mForegroundServiceUsageConsumePower,
upperHistEntry.mForegroundServiceUsageConsumePower,
ratio);
final double backgroundUsageConsumePower = interpolate(
lowerHistEntry == null ? 0 : lowerHistEntry.mBackgroundUsageConsumePower,
upperHistEntry.mBackgroundUsageConsumePower,
ratio);
final double cachedUsageConsumePower = interpolate(
lowerHistEntry == null ? 0 : lowerHistEntry.mCachedUsageConsumePower,
upperHistEntry.mCachedUsageConsumePower,
ratio);
final double foregroundUsageTimeInMs = interpolate( final double foregroundUsageTimeInMs = interpolate(
lowerHistEntry == null ? 0 : lowerHistEntry.mForegroundUsageTimeInMs, (double) (lowerHistEntry == null ? 0 : lowerHistEntry.mForegroundUsageTimeInMs),
upperHistEntry.mForegroundUsageTimeInMs, (double) upperHistEntry.mForegroundUsageTimeInMs,
ratio);
final double foregroundServiceUsageTimeInMs = interpolate(
(double) (lowerHistEntry == null
? 0
: lowerHistEntry.mForegroundServiceUsageTimeInMs),
(double) upperHistEntry.mForegroundServiceUsageTimeInMs,
ratio); ratio);
final double backgroundUsageTimeInMs = interpolate( final double backgroundUsageTimeInMs = interpolate(
lowerHistEntry == null ? 0 : lowerHistEntry.mBackgroundUsageTimeInMs, (double) (lowerHistEntry == null ? 0 : lowerHistEntry.mBackgroundUsageTimeInMs),
upperHistEntry.mBackgroundUsageTimeInMs, (double) upperHistEntry.mBackgroundUsageTimeInMs,
ratio); ratio);
// Checks whether there is any abnormal cases! // Checks whether there is any abnormal cases!
if (upperHistEntry.mConsumePower < consumePower if (upperHistEntry.mConsumePower < consumePower
|| upperHistEntry.mForegroundUsageConsumePower < foregroundUsageConsumePower
|| upperHistEntry.mForegroundServiceUsageConsumePower
< foregroundServiceUsageConsumePower
|| upperHistEntry.mBackgroundUsageConsumePower < backgroundUsageConsumePower
|| upperHistEntry.mCachedUsageConsumePower < cachedUsageConsumePower
|| upperHistEntry.mForegroundUsageTimeInMs < foregroundUsageTimeInMs || upperHistEntry.mForegroundUsageTimeInMs < foregroundUsageTimeInMs
|| upperHistEntry.mForegroundServiceUsageTimeInMs < foregroundServiceUsageTimeInMs
|| upperHistEntry.mBackgroundUsageTimeInMs < backgroundUsageTimeInMs) { || upperHistEntry.mBackgroundUsageTimeInMs < backgroundUsageTimeInMs) {
if (DEBUG) { if (DEBUG) {
Log.w(TAG, String.format( Log.w(TAG, String.format(
@@ -299,7 +360,12 @@ public class BatteryHistEntry {
/*timestamp=*/ slotTimestamp, /*timestamp=*/ slotTimestamp,
totalPower, totalPower,
consumePower, consumePower,
foregroundUsageConsumePower,
foregroundServiceUsageConsumePower,
backgroundUsageConsumePower,
cachedUsageConsumePower,
Math.round(foregroundUsageTimeInMs), Math.round(foregroundUsageTimeInMs),
Math.round(foregroundServiceUsageTimeInMs),
Math.round(backgroundUsageTimeInMs), Math.round(backgroundUsageTimeInMs),
(int) Math.round(batteryLevel)); (int) Math.round(batteryLevel));
} }

305
src/com/android/settings/fuelgauge/batteryusage/ConvertUtils.java
View File

@@ -23,46 +23,22 @@ import android.os.BatteryUsageStats;
import android.os.Build; import android.os.Build;
import android.os.LocaleList; import android.os.LocaleList;
import android.os.UserHandle; import android.os.UserHandle;
import android.os.UserManager;
import android.text.format.DateFormat; import android.text.format.DateFormat;
import android.text.format.DateUtils;
import android.util.ArraySet;
import android.util.Base64; import android.util.Base64;
import android.util.Log;
import androidx.annotation.VisibleForTesting; import androidx.annotation.VisibleForTesting;
import com.android.settings.Utils;
import com.android.settings.fuelgauge.BatteryUtils; import com.android.settings.fuelgauge.BatteryUtils;
import com.android.settings.overlay.FeatureFactory;
import java.lang.annotation.Retention; import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy; import java.lang.annotation.RetentionPolicy;
import java.time.Duration;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Locale; import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.TimeZone; import java.util.TimeZone;
/** A utility class to convert data into another types. */ /** A utility class to convert data into another types. */
public final class ConvertUtils { public final class ConvertUtils {
private static final boolean DEBUG = false;
private static final String TAG = "ConvertUtils"; private static final String TAG = "ConvertUtils";
private static final Map<String, BatteryHistEntry> EMPTY_BATTERY_MAP = new HashMap<>();
private static final BatteryHistEntry EMPTY_BATTERY_HIST_ENTRY =
new BatteryHistEntry(new ContentValues());
// Maximum total time value for each slot cumulative data at most 2 hours.
private static final float TOTAL_TIME_THRESHOLD = DateUtils.HOUR_IN_MILLIS * 2;
@VisibleForTesting
static double PERCENTAGE_OF_TOTAL_THRESHOLD = 1f;
/** Invalid system battery consumer drain type. */
public static final int INVALID_DRAIN_TYPE = -1;
/** A fake package name to represent no BatteryEntry data. */ /** A fake package name to represent no BatteryEntry data. */
public static final String FAKE_PACKAGE_NAME = "fake_package"; public static final String FAKE_PACKAGE_NAME = "fake_package";
@@ -198,167 +174,15 @@ public final class ConvertUtils {
return DateFormat.format(pattern, timestamp).toString(); return DateFormat.format(pattern, timestamp).toString();
} }
/** Gets indexed battery usage data for each corresponding time slot. */
public static Map<Integer, List<BatteryDiffEntry>> getIndexedUsageMap(
final Context context,
final int timeSlotSize,
final long[] batteryHistoryKeys,
final Map<Long, Map<String, BatteryHistEntry>> batteryHistoryMap,
final boolean purgeLowPercentageAndFakeData) {
if (batteryHistoryMap == null || batteryHistoryMap.isEmpty()) {
return new HashMap<>();
}
final Map<Integer, List<BatteryDiffEntry>> resultMap = new HashMap<>();
// Each time slot usage diff data =
// Math.abs(timestamp[i+2] data - timestamp[i+1] data) +
// Math.abs(timestamp[i+1] data - timestamp[i] data);
// since we want to aggregate every two hours data into a single time slot.
final int timestampStride = 2;
for (int index = 0; index < timeSlotSize; index++) {
final Long currentTimestamp =
Long.valueOf(batteryHistoryKeys[index * timestampStride]);
final Long nextTimestamp =
Long.valueOf(batteryHistoryKeys[index * timestampStride + 1]);
final Long nextTwoTimestamp =
Long.valueOf(batteryHistoryKeys[index * timestampStride + 2]);
// Fetches BatteryHistEntry data from corresponding time slot.
final Map<String, BatteryHistEntry> currentBatteryHistMap =
batteryHistoryMap.getOrDefault(currentTimestamp, EMPTY_BATTERY_MAP);
final Map<String, BatteryHistEntry> nextBatteryHistMap =
batteryHistoryMap.getOrDefault(nextTimestamp, EMPTY_BATTERY_MAP);
final Map<String, BatteryHistEntry> nextTwoBatteryHistMap =
batteryHistoryMap.getOrDefault(nextTwoTimestamp, EMPTY_BATTERY_MAP);
// We should not get the empty list since we have at least one fake data to record
// the battery level and status in each time slot, the empty list is used to
// represent there is no enough data to apply interpolation arithmetic.
if (currentBatteryHistMap.isEmpty()
|| nextBatteryHistMap.isEmpty()
|| nextTwoBatteryHistMap.isEmpty()) {
resultMap.put(Integer.valueOf(index), new ArrayList<BatteryDiffEntry>());
continue;
}
// Collects all keys in these three time slot records as all populations.
final Set<String> allBatteryHistEntryKeys = new ArraySet<>();
allBatteryHistEntryKeys.addAll(currentBatteryHistMap.keySet());
allBatteryHistEntryKeys.addAll(nextBatteryHistMap.keySet());
allBatteryHistEntryKeys.addAll(nextTwoBatteryHistMap.keySet());
double totalConsumePower = 0.0;
final List<BatteryDiffEntry> batteryDiffEntryList = new ArrayList<>();
// Adds a specific time slot BatteryDiffEntry list into result map.
resultMap.put(Integer.valueOf(index), batteryDiffEntryList);
// Calculates all packages diff usage data in a specific time slot.
for (String key : allBatteryHistEntryKeys) {
final BatteryHistEntry currentEntry =
currentBatteryHistMap.getOrDefault(key, EMPTY_BATTERY_HIST_ENTRY);
final BatteryHistEntry nextEntry =
nextBatteryHistMap.getOrDefault(key, EMPTY_BATTERY_HIST_ENTRY);
final BatteryHistEntry nextTwoEntry =
nextTwoBatteryHistMap.getOrDefault(key, EMPTY_BATTERY_HIST_ENTRY);
// Cumulative values is a specific time slot for a specific app.
long foregroundUsageTimeInMs =
getDiffValue(
currentEntry.mForegroundUsageTimeInMs,
nextEntry.mForegroundUsageTimeInMs,
nextTwoEntry.mForegroundUsageTimeInMs);
long backgroundUsageTimeInMs =
getDiffValue(
currentEntry.mBackgroundUsageTimeInMs,
nextEntry.mBackgroundUsageTimeInMs,
nextTwoEntry.mBackgroundUsageTimeInMs);
double consumePower =
getDiffValue(
currentEntry.mConsumePower,
nextEntry.mConsumePower,
nextTwoEntry.mConsumePower);
// Excludes entry since we don't have enough data to calculate.
if (foregroundUsageTimeInMs == 0
&& backgroundUsageTimeInMs == 0
&& consumePower == 0) {
continue;
}
final BatteryHistEntry selectedBatteryEntry =
selectBatteryHistEntry(currentEntry, nextEntry, nextTwoEntry);
if (selectedBatteryEntry == null) {
continue;
}
// Forces refine the cumulative value since it may introduce deviation
// error since we will apply the interpolation arithmetic.
final float totalUsageTimeInMs =
foregroundUsageTimeInMs + backgroundUsageTimeInMs;
if (totalUsageTimeInMs > TOTAL_TIME_THRESHOLD) {
final float ratio = TOTAL_TIME_THRESHOLD / totalUsageTimeInMs;
if (DEBUG) {
Log.w(TAG, String.format("abnormal usage time %d|%d for:\n%s",
Duration.ofMillis(foregroundUsageTimeInMs).getSeconds(),
Duration.ofMillis(backgroundUsageTimeInMs).getSeconds(),
currentEntry));
}
foregroundUsageTimeInMs =
Math.round(foregroundUsageTimeInMs * ratio);
backgroundUsageTimeInMs =
Math.round(backgroundUsageTimeInMs * ratio);
consumePower = consumePower * ratio;
}
totalConsumePower += consumePower;
batteryDiffEntryList.add(
new BatteryDiffEntry(
context,
foregroundUsageTimeInMs,
backgroundUsageTimeInMs,
consumePower,
selectedBatteryEntry));
}
// Sets total consume power data into all BatteryDiffEntry in the same slot.
for (BatteryDiffEntry diffEntry : batteryDiffEntryList) {
diffEntry.setTotalConsumePower(totalConsumePower);
}
}
insert24HoursData(BatteryChartViewModel.SELECTED_INDEX_ALL, resultMap);
resolveMultiUsersData(context, resultMap);
if (purgeLowPercentageAndFakeData) {
purgeLowPercentageAndFakeData(context, resultMap);
}
return resultMap;
}
@VisibleForTesting @VisibleForTesting
static void resolveMultiUsersData( static Locale getLocale(Context context) {
final Context context, if (context == null) {
final Map<Integer, List<BatteryDiffEntry>> indexedUsageMap) { return Locale.getDefault();
final int currentUserId = context.getUserId();
final UserHandle userHandle =
Utils.getManagedProfile(context.getSystemService(UserManager.class));
final int workProfileUserId =
userHandle != null ? userHandle.getIdentifier() : Integer.MIN_VALUE;
// Loops for all BatteryDiffEntry in the different slots.
for (List<BatteryDiffEntry> entryList : indexedUsageMap.values()) {
double consumePowerFromOtherUsers = 0f;
double consumePercentageFromOtherUsers = 0f;
final Iterator<BatteryDiffEntry> iterator = entryList.iterator();
while (iterator.hasNext()) {
final BatteryDiffEntry entry = iterator.next();
final BatteryHistEntry batteryHistEntry = entry.mBatteryHistEntry;
if (batteryHistEntry.mConsumerType != CONSUMER_TYPE_UID_BATTERY) {
continue;
}
// Whether the BatteryHistEntry represents the current user data?
if (batteryHistEntry.mUserId == currentUserId
|| batteryHistEntry.mUserId == workProfileUserId) {
continue;
}
// Removes and aggregates non-current users data from the list.
iterator.remove();
consumePowerFromOtherUsers += entry.mConsumePower;
consumePercentageFromOtherUsers += entry.getPercentOfTotal();
}
if (consumePercentageFromOtherUsers != 0) {
entryList.add(createOtherUsersEntry(context, consumePowerFromOtherUsers,
consumePercentageFromOtherUsers));
}
} }
final LocaleList locales =
context.getResources().getConfiguration().getLocales();
return locales != null && !locales.isEmpty() ? locales.get(0)
: Locale.getDefault();
} }
private static BatteryInformation constructBatteryInformation( private static BatteryInformation constructBatteryInformation(
@@ -387,121 +211,18 @@ public final class ConvertUtils {
.setAppLabel(entry.getLabel() != null ? entry.getLabel() : "") .setAppLabel(entry.getLabel() != null ? entry.getLabel() : "")
.setTotalPower(batteryUsageStats.getConsumedPower()) .setTotalPower(batteryUsageStats.getConsumedPower())
.setConsumePower(entry.getConsumedPower()) .setConsumePower(entry.getConsumedPower())
.setForegroundUsageConsumePower(entry.getConsumedPowerInForeground())
.setForegroundServiceUsageConsumePower(
entry.getConsumedPowerInForegroundService())
.setBackgroundUsageConsumePower(entry.getConsumedPowerInBackground())
.setCachedUsageConsumePower(entry.getConsumedPowerInCached())
.setPercentOfTotal(entry.mPercent) .setPercentOfTotal(entry.mPercent)
.setDrainType(entry.getPowerComponentId()) .setDrainType(entry.getPowerComponentId())
.setForegroundUsageTimeInMs(entry.getTimeInForegroundMs()) .setForegroundUsageTimeInMs(entry.getTimeInForegroundMs())
.setForegroundServiceUsageTimeInMs(entry.getTimeInForegroundServiceMs())
.setBackgroundUsageTimeInMs(entry.getTimeInBackgroundMs()); .setBackgroundUsageTimeInMs(entry.getTimeInBackgroundMs());
} }
return batteryInformationBuilder.build(); return batteryInformationBuilder.build();
} }
private static void insert24HoursData(
final int desiredIndex,
final Map<Integer, List<BatteryDiffEntry>> indexedUsageMap) {
final Map<String, BatteryDiffEntry> resultMap = new HashMap<>();
double totalConsumePower = 0f;
// Loops for all BatteryDiffEntry and aggregate them together.
for (List<BatteryDiffEntry> entryList : indexedUsageMap.values()) {
for (BatteryDiffEntry entry : entryList) {
final String key = entry.mBatteryHistEntry.getKey();
final BatteryDiffEntry oldBatteryDiffEntry = resultMap.get(key);
// Creates new BatteryDiffEntry if we don't have it.
if (oldBatteryDiffEntry == null) {
resultMap.put(key, entry.clone());
} else {
// Sums up some fields data into the existing one.
oldBatteryDiffEntry.mForegroundUsageTimeInMs +=
entry.mForegroundUsageTimeInMs;
oldBatteryDiffEntry.mBackgroundUsageTimeInMs +=
entry.mBackgroundUsageTimeInMs;
oldBatteryDiffEntry.mConsumePower += entry.mConsumePower;
}
totalConsumePower += entry.mConsumePower;
}
}
final List<BatteryDiffEntry> resultList = new ArrayList<>(resultMap.values());
// Sets total 24 hours consume power data into all BatteryDiffEntry.
for (BatteryDiffEntry entry : resultList) {
entry.setTotalConsumePower(totalConsumePower);
}
indexedUsageMap.put(Integer.valueOf(desiredIndex), resultList);
}
// Removes low percentage data and fake usage data, which will be zero value.
private static void purgeLowPercentageAndFakeData(
final Context context,
final Map<Integer, List<BatteryDiffEntry>> indexedUsageMap) {
final Set<CharSequence> backgroundUsageTimeHideList =
FeatureFactory.getFactory(context)
.getPowerUsageFeatureProvider(context)
.getHideBackgroundUsageTimeSet(context);
for (List<BatteryDiffEntry> entries : indexedUsageMap.values()) {
final Iterator<BatteryDiffEntry> iterator = entries.iterator();
while (iterator.hasNext()) {
final BatteryDiffEntry entry = iterator.next();
if (entry.getPercentOfTotal() < PERCENTAGE_OF_TOTAL_THRESHOLD
|| FAKE_PACKAGE_NAME.equals(entry.getPackageName())) {
iterator.remove();
}
final String packageName = entry.getPackageName();
if (packageName != null
&& !backgroundUsageTimeHideList.isEmpty()
&& backgroundUsageTimeHideList.contains(packageName)) {
entry.mBackgroundUsageTimeInMs = 0;
}
}
}
}
private static long getDiffValue(long v1, long v2, long v3) {
return (v2 > v1 ? v2 - v1 : 0) + (v3 > v2 ? v3 - v2 : 0);
}
private static double getDiffValue(double v1, double v2, double v3) {
return (v2 > v1 ? v2 - v1 : 0) + (v3 > v2 ? v3 - v2 : 0);
}
private static BatteryHistEntry selectBatteryHistEntry(
BatteryHistEntry entry1,
BatteryHistEntry entry2,
BatteryHistEntry entry3) {
if (entry1 != null && entry1 != EMPTY_BATTERY_HIST_ENTRY) {
return entry1;
} else if (entry2 != null && entry2 != EMPTY_BATTERY_HIST_ENTRY) {
return entry2;
} else {
return entry3 != null && entry3 != EMPTY_BATTERY_HIST_ENTRY
? entry3 : null;
}
}
@VisibleForTesting
static Locale getLocale(Context context) {
if (context == null) {
return Locale.getDefault();
}
final LocaleList locales =
context.getResources().getConfiguration().getLocales();
return locales != null && !locales.isEmpty() ? locales.get(0)
: Locale.getDefault();
}
private static BatteryDiffEntry createOtherUsersEntry(
Context context, double consumePower, double consumePercentage) {
final ContentValues values = new ContentValues();
values.put(BatteryHistEntry.KEY_UID, BatteryUtils.UID_OTHER_USERS);
values.put(BatteryHistEntry.KEY_USER_ID, BatteryUtils.UID_OTHER_USERS);
values.put(BatteryHistEntry.KEY_CONSUMER_TYPE, CONSUMER_TYPE_UID_BATTERY);
// We will show the percentage for the "other users" item only, the aggregated
// running time information is useless for users to identify individual apps.
final BatteryDiffEntry batteryDiffEntry = new BatteryDiffEntry(
context,
/*foregroundUsageTimeInMs=*/ 0,
/*backgroundUsageTimeInMs=*/ 0,
consumePower,
new BatteryHistEntry(values));
batteryDiffEntry.setTotalConsumePower(100 * consumePower / consumePercentage);
return batteryDiffEntry;
}
} }

77
src/com/android/settings/fuelgauge/batteryusage/DataProcessor.java
View File

@@ -87,9 +87,6 @@ public final class DataProcessor {
@VisibleForTesting @VisibleForTesting
static final int SELECTED_INDEX_ALL = BatteryChartViewModel.SELECTED_INDEX_ALL; static final int SELECTED_INDEX_ALL = BatteryChartViewModel.SELECTED_INDEX_ALL;
/** A fake package name to represent no BatteryEntry data. */
public static final String FAKE_PACKAGE_NAME = "fake_package";
/** A callback listener when battery usage loading async task is executed. */ /** A callback listener when battery usage loading async task is executed. */
public interface UsageMapAsyncResponse { public interface UsageMapAsyncResponse {
/** The callback function when batteryUsageMap is loaded. */ /** The callback function when batteryUsageMap is loaded. */
@@ -174,7 +171,11 @@ public final class DataProcessor {
@Nullable @Nullable
public static BatteryUsageStats getBatteryUsageStats(final Context context) { public static BatteryUsageStats getBatteryUsageStats(final Context context) {
final BatteryUsageStatsQuery batteryUsageStatsQuery = final BatteryUsageStatsQuery batteryUsageStatsQuery =
new BatteryUsageStatsQuery.Builder().includeBatteryHistory().build(); new BatteryUsageStatsQuery
.Builder()
.includeBatteryHistory()
.includeProcessStateData()
.build();
return context.getSystemService(BatteryStatsManager.class) return context.getSystemService(BatteryStatsManager.class)
.getBatteryUsageStats(batteryUsageStatsQuery); .getBatteryUsageStats(batteryUsageStatsQuery);
} }
@@ -478,8 +479,13 @@ public final class DataProcessor {
final BatteryDiffEntry currentBatteryDiffEntry = new BatteryDiffEntry( final BatteryDiffEntry currentBatteryDiffEntry = new BatteryDiffEntry(
context, context,
entry.mForegroundUsageTimeInMs, entry.mForegroundUsageTimeInMs,
entry.mForegroundServiceUsageTimeInMs,
entry.mBackgroundUsageTimeInMs, entry.mBackgroundUsageTimeInMs,
entry.mConsumePower, entry.mConsumePower,
entry.mForegroundUsageConsumePower,
entry.mForegroundServiceUsageConsumePower,
entry.mBackgroundUsageConsumePower,
entry.mCachedUsageConsumePower,
entry); entry);
if (currentBatteryDiffEntry.isSystemEntry()) { if (currentBatteryDiffEntry.isSystemEntry()) {
systemEntries.add(currentBatteryDiffEntry); systemEntries.add(currentBatteryDiffEntry);
@@ -567,10 +573,12 @@ public final class DataProcessor {
return batteryEntryList.stream() return batteryEntryList.stream()
.filter(entry -> { .filter(entry -> {
final long foregroundMs = entry.getTimeInForegroundMs(); final long foregroundMs = entry.getTimeInForegroundMs();
final long foregroundServiceMs = entry.getTimeInForegroundServiceMs();
final long backgroundMs = entry.getTimeInBackgroundMs(); final long backgroundMs = entry.getTimeInBackgroundMs();
return entry.getConsumedPower() > 0 return entry.getConsumedPower() > 0
|| (entry.getConsumedPower() == 0 || (entry.getConsumedPower() == 0
&& (foregroundMs != 0 || backgroundMs != 0)); && (foregroundMs != 0 || foregroundServiceMs != 0
|| backgroundMs != 0));
}) })
.map(entry -> ConvertUtils.convertToBatteryHistEntry( .map(entry -> ConvertUtils.convertToBatteryHistEntry(
entry, entry,
@@ -691,9 +699,14 @@ public final class DataProcessor {
if (lowerEntry != null) { if (lowerEntry != null) {
final boolean invalidForegroundUsageTime = final boolean invalidForegroundUsageTime =
lowerEntry.mForegroundUsageTimeInMs > upperEntry.mForegroundUsageTimeInMs; lowerEntry.mForegroundUsageTimeInMs > upperEntry.mForegroundUsageTimeInMs;
final boolean invalidForegroundServiceUsageTime =
lowerEntry.mForegroundServiceUsageTimeInMs
> upperEntry.mForegroundServiceUsageTimeInMs;
final boolean invalidBackgroundUsageTime = final boolean invalidBackgroundUsageTime =
lowerEntry.mBackgroundUsageTimeInMs > upperEntry.mBackgroundUsageTimeInMs; lowerEntry.mBackgroundUsageTimeInMs > upperEntry.mBackgroundUsageTimeInMs;
if (invalidForegroundUsageTime || invalidBackgroundUsageTime) { if (invalidForegroundUsageTime
|| invalidForegroundServiceUsageTime
|| invalidBackgroundUsageTime) {
newHistEntryMap.put(entryKey, upperEntry); newHistEntryMap.put(entryKey, upperEntry);
log(context, "abnormal reset condition is found", currentSlot, upperEntry); log(context, "abnormal reset condition is found", currentSlot, upperEntry);
continue; continue;
@@ -924,6 +937,11 @@ public final class DataProcessor {
currentEntry.mForegroundUsageTimeInMs, currentEntry.mForegroundUsageTimeInMs,
nextEntry.mForegroundUsageTimeInMs, nextEntry.mForegroundUsageTimeInMs,
nextTwoEntry.mForegroundUsageTimeInMs); nextTwoEntry.mForegroundUsageTimeInMs);
long foregroundServiceUsageTimeInMs =
getDiffValue(
currentEntry.mForegroundServiceUsageTimeInMs,
nextEntry.mForegroundServiceUsageTimeInMs,
nextTwoEntry.mForegroundServiceUsageTimeInMs);
long backgroundUsageTimeInMs = long backgroundUsageTimeInMs =
getDiffValue( getDiffValue(
currentEntry.mBackgroundUsageTimeInMs, currentEntry.mBackgroundUsageTimeInMs,
@@ -934,8 +952,29 @@ public final class DataProcessor {
currentEntry.mConsumePower, currentEntry.mConsumePower,
nextEntry.mConsumePower, nextEntry.mConsumePower,
nextTwoEntry.mConsumePower); nextTwoEntry.mConsumePower);
double foregroundUsageConsumePower =
getDiffValue(
currentEntry.mForegroundUsageConsumePower,
nextEntry.mForegroundUsageConsumePower,
nextTwoEntry.mForegroundUsageConsumePower);
double foregroundServiceUsageConsumePower =
getDiffValue(
currentEntry.mForegroundServiceUsageConsumePower,
nextEntry.mForegroundServiceUsageConsumePower,
nextTwoEntry.mForegroundServiceUsageConsumePower);
double backgroundUsageConsumePower =
getDiffValue(
currentEntry.mBackgroundUsageConsumePower,
nextEntry.mBackgroundUsageConsumePower,
nextTwoEntry.mBackgroundUsageConsumePower);
double cachedUsageConsumePower =
getDiffValue(
currentEntry.mCachedUsageConsumePower,
nextEntry.mCachedUsageConsumePower,
nextTwoEntry.mCachedUsageConsumePower);
// Excludes entry since we don't have enough data to calculate. // Excludes entry since we don't have enough data to calculate.
if (foregroundUsageTimeInMs == 0 if (foregroundUsageTimeInMs == 0
&& foregroundServiceUsageTimeInMs == 0
&& backgroundUsageTimeInMs == 0 && backgroundUsageTimeInMs == 0
&& consumePower == 0) { && consumePower == 0) {
continue; continue;
@@ -947,6 +986,7 @@ public final class DataProcessor {
} }
// Forces refine the cumulative value since it may introduce deviation error since we // Forces refine the cumulative value since it may introduce deviation error since we
// will apply the interpolation arithmetic. // will apply the interpolation arithmetic.
// TODO: update this value after the new API for foreground service is completed.
final float totalUsageTimeInMs = final float totalUsageTimeInMs =
foregroundUsageTimeInMs + backgroundUsageTimeInMs; foregroundUsageTimeInMs + backgroundUsageTimeInMs;
if (totalUsageTimeInMs > TOTAL_HOURLY_TIME_THRESHOLD) { if (totalUsageTimeInMs > TOTAL_HOURLY_TIME_THRESHOLD) {
@@ -959,9 +999,15 @@ public final class DataProcessor {
} }
foregroundUsageTimeInMs = foregroundUsageTimeInMs =
Math.round(foregroundUsageTimeInMs * ratio); Math.round(foregroundUsageTimeInMs * ratio);
foregroundServiceUsageTimeInMs =
Math.round(foregroundServiceUsageTimeInMs * ratio);
backgroundUsageTimeInMs = backgroundUsageTimeInMs =
Math.round(backgroundUsageTimeInMs * ratio); Math.round(backgroundUsageTimeInMs * ratio);
consumePower = consumePower * ratio; consumePower = consumePower * ratio;
foregroundUsageConsumePower = foregroundUsageConsumePower * ratio;
foregroundServiceUsageConsumePower = foregroundServiceUsageConsumePower * ratio;
backgroundUsageConsumePower = backgroundUsageConsumePower * ratio;
cachedUsageConsumePower = cachedUsageConsumePower * ratio;
} }
totalConsumePower += consumePower; totalConsumePower += consumePower;
@@ -973,8 +1019,13 @@ public final class DataProcessor {
final BatteryDiffEntry currentBatteryDiffEntry = new BatteryDiffEntry( final BatteryDiffEntry currentBatteryDiffEntry = new BatteryDiffEntry(
context, context,
foregroundUsageTimeInMs, foregroundUsageTimeInMs,
foregroundServiceUsageTimeInMs,
backgroundUsageTimeInMs, backgroundUsageTimeInMs,
consumePower, consumePower,
foregroundUsageConsumePower,
foregroundServiceUsageConsumePower,
backgroundUsageConsumePower,
cachedUsageConsumePower,
selectedBatteryEntry); selectedBatteryEntry);
if (currentBatteryDiffEntry.isSystemEntry()) { if (currentBatteryDiffEntry.isSystemEntry()) {
systemEntries.add(currentBatteryDiffEntry); systemEntries.add(currentBatteryDiffEntry);
@@ -1054,9 +1105,16 @@ public final class DataProcessor {
// Sums up some field data into the existing one. // Sums up some field data into the existing one.
oldBatteryDiffEntry.mForegroundUsageTimeInMs += oldBatteryDiffEntry.mForegroundUsageTimeInMs +=
entry.mForegroundUsageTimeInMs; entry.mForegroundUsageTimeInMs;
oldBatteryDiffEntry.mForegroundServiceUsageTimeInMs +=
entry.mForegroundServiceUsageTimeInMs;
oldBatteryDiffEntry.mBackgroundUsageTimeInMs += oldBatteryDiffEntry.mBackgroundUsageTimeInMs +=
entry.mBackgroundUsageTimeInMs; entry.mBackgroundUsageTimeInMs;
oldBatteryDiffEntry.mConsumePower += entry.mConsumePower; oldBatteryDiffEntry.mConsumePower += entry.mConsumePower;
oldBatteryDiffEntry.mForegroundUsageConsumePower += entry.mForegroundUsageConsumePower;
oldBatteryDiffEntry.mForegroundServiceUsageConsumePower
+= entry.mForegroundServiceUsageConsumePower;
oldBatteryDiffEntry.mBackgroundUsageConsumePower += entry.mBackgroundUsageConsumePower;
oldBatteryDiffEntry.mCachedUsageConsumePower += entry.mCachedUsageConsumePower;
} }
} }
@@ -1097,7 +1155,7 @@ public final class DataProcessor {
final BatteryDiffEntry entry = iterator.next(); final BatteryDiffEntry entry = iterator.next();
final String packageName = entry.getPackageName(); final String packageName = entry.getPackageName();
if (entry.getPercentOfTotal() < PERCENTAGE_OF_TOTAL_THRESHOLD if (entry.getPercentOfTotal() < PERCENTAGE_OF_TOTAL_THRESHOLD
|| FAKE_PACKAGE_NAME.equals(packageName) || ConvertUtils.FAKE_PACKAGE_NAME.equals(packageName)
|| contains(packageName, notAllowShowEntryPackages)) { || contains(packageName, notAllowShowEntryPackages)) {
iterator.remove(); iterator.remove();
} }
@@ -1346,8 +1404,13 @@ public final class DataProcessor {
final BatteryDiffEntry batteryDiffEntry = new BatteryDiffEntry( final BatteryDiffEntry batteryDiffEntry = new BatteryDiffEntry(
context, context,
/*foregroundUsageTimeInMs=*/ 0, /*foregroundUsageTimeInMs=*/ 0,
/*foregroundServiceUsageTimeInMs=*/ 0,
/*backgroundUsageTimeInMs=*/ 0, /*backgroundUsageTimeInMs=*/ 0,
consumePower, consumePower,
/*foregroundUsageConsumePower=*/ 0,
/*foregroundServiceUsageConsumePower=*/ 0,
/*backgroundUsageConsumePower=*/ 0,
/*cachedUsageConsumePower=*/ 0,
new BatteryHistEntry(values)); new BatteryHistEntry(values));
return batteryDiffEntry; return batteryDiffEntry;
} }

11
src/com/android/settings/fuelgauge/batteryusage/DatabaseUtils.java
View File

@@ -164,15 +164,20 @@ public final class DatabaseUtils {
batteryEntryList.stream() batteryEntryList.stream()
.filter(entry -> { .filter(entry -> {
final long foregroundMs = entry.getTimeInForegroundMs(); final long foregroundMs = entry.getTimeInForegroundMs();
final long foregroundServiceMs = entry.getTimeInForegroundServiceMs();
final long backgroundMs = entry.getTimeInBackgroundMs(); final long backgroundMs = entry.getTimeInBackgroundMs();
if (entry.getConsumedPower() == 0 if (entry.getConsumedPower() == 0
&& (foregroundMs != 0 || backgroundMs != 0)) { && (foregroundMs != 0
|| foregroundServiceMs != 0
|| backgroundMs != 0)) {
Log.w(TAG, String.format( Log.w(TAG, String.format(
"no consumed power but has running time for %s time=%d|%d", "no consumed power but has running time for %s time=%d|%d|%d",
entry.getLabel(), foregroundMs, backgroundMs)); entry.getLabel(), foregroundMs, foregroundServiceMs,
backgroundMs));
} }
return entry.getConsumedPower() != 0 return entry.getConsumedPower() != 0
|| foregroundMs != 0 || foregroundMs != 0
|| foregroundServiceMs != 0
|| backgroundMs != 0; || backgroundMs != 0;
}) })
.forEach(entry -> valuesList.add( .forEach(entry -> valuesList.add(

19
tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryChartPreferenceControllerTest.java
View File

@@ -127,8 +127,13 @@ public final class BatteryChartPreferenceControllerTest {
mBatteryDiffEntry = new BatteryDiffEntry( mBatteryDiffEntry = new BatteryDiffEntry(
mContext, mContext,
/*foregroundUsageTimeInMs=*/ 1, /*foregroundUsageTimeInMs=*/ 1,
/*foregroundServiceUsageTimeInMs=*/ 3,
/*backgroundUsageTimeInMs=*/ 2, /*backgroundUsageTimeInMs=*/ 2,
/*consumePower=*/ 3, /*consumePower=*/ 3,
/*foregroundUsageConsumePower=*/ 0,
/*foregroundServiceUsageConsumePower=*/ 1,
/*backgroundUsageConsumePower=*/ 2,
/*cachedUsageConsumePower=*/ 0,
mBatteryHistEntry); mBatteryHistEntry);
mBatteryDiffEntry = spy(mBatteryDiffEntry); mBatteryDiffEntry = spy(mBatteryDiffEntry);
// Adds fake testing data. // Adds fake testing data.
@@ -458,6 +463,7 @@ public final class BatteryChartPreferenceControllerTest {
mBatteryChartPreferenceController.setPreferenceSummary( mBatteryChartPreferenceController.setPreferenceSummary(
pref, createBatteryDiffEntry( pref, createBatteryDiffEntry(
/*foregroundUsageTimeInMs=*/ 0, /*foregroundUsageTimeInMs=*/ 0,
/*foregroundServiceUsageTimeInMs=*/ 0,
/*backgroundUsageTimeInMs=*/ 0)); /*backgroundUsageTimeInMs=*/ 0));
assertThat(pref.getSummary()).isNull(); assertThat(pref.getSummary()).isNull();
} }
@@ -470,6 +476,7 @@ public final class BatteryChartPreferenceControllerTest {
mBatteryChartPreferenceController.setPreferenceSummary( mBatteryChartPreferenceController.setPreferenceSummary(
pref, createBatteryDiffEntry( pref, createBatteryDiffEntry(
/*foregroundUsageTimeInMs=*/ 0, /*foregroundUsageTimeInMs=*/ 0,
/*foregroundServiceUsageTimeInMs=*/ 0,
/*backgroundUsageTimeInMs=*/ DateUtils.MINUTE_IN_MILLIS)); /*backgroundUsageTimeInMs=*/ DateUtils.MINUTE_IN_MILLIS));
assertThat(pref.getSummary()).isEqualTo("Background: 1 min"); assertThat(pref.getSummary()).isEqualTo("Background: 1 min");
} }
@@ -482,6 +489,7 @@ public final class BatteryChartPreferenceControllerTest {
mBatteryChartPreferenceController.setPreferenceSummary( mBatteryChartPreferenceController.setPreferenceSummary(
pref, createBatteryDiffEntry( pref, createBatteryDiffEntry(
/*foregroundUsageTimeInMs=*/ 100, /*foregroundUsageTimeInMs=*/ 100,
/*foregroundServiceUsageTimeInMs=*/ 200,
/*backgroundUsageTimeInMs=*/ 200)); /*backgroundUsageTimeInMs=*/ 200));
assertThat(pref.getSummary()).isEqualTo("Total: less than a min"); assertThat(pref.getSummary()).isEqualTo("Total: less than a min");
} }
@@ -494,6 +502,7 @@ public final class BatteryChartPreferenceControllerTest {
mBatteryChartPreferenceController.setPreferenceSummary( mBatteryChartPreferenceController.setPreferenceSummary(
pref, createBatteryDiffEntry( pref, createBatteryDiffEntry(
/*foregroundUsageTimeInMs=*/ DateUtils.MINUTE_IN_MILLIS, /*foregroundUsageTimeInMs=*/ DateUtils.MINUTE_IN_MILLIS,
/*foregroundServiceUsageTimeInMs=*/ 100,
/*backgroundUsageTimeInMs=*/ 200)); /*backgroundUsageTimeInMs=*/ 200));
assertThat(pref.getSummary()) assertThat(pref.getSummary())
.isEqualTo("Total: 1 min\nBackground: less than a min"); .isEqualTo("Total: 1 min\nBackground: less than a min");
@@ -507,6 +516,7 @@ public final class BatteryChartPreferenceControllerTest {
mBatteryChartPreferenceController.setPreferenceSummary( mBatteryChartPreferenceController.setPreferenceSummary(
pref, createBatteryDiffEntry( pref, createBatteryDiffEntry(
/*foregroundUsageTimeInMs=*/ DateUtils.MINUTE_IN_MILLIS, /*foregroundUsageTimeInMs=*/ DateUtils.MINUTE_IN_MILLIS,
/*foregroundServiceUsageTimeInMs=*/ DateUtils.MINUTE_IN_MILLIS,
/*backgroundUsageTimeInMs=*/ DateUtils.MINUTE_IN_MILLIS)); /*backgroundUsageTimeInMs=*/ DateUtils.MINUTE_IN_MILLIS));
assertThat(pref.getSummary()).isEqualTo("Total: 2 min\nBackground: 1 min"); assertThat(pref.getSummary()).isEqualTo("Total: 2 min\nBackground: 1 min");
} }
@@ -717,10 +727,13 @@ public final class BatteryChartPreferenceControllerTest {
} }
private BatteryDiffEntry createBatteryDiffEntry( private BatteryDiffEntry createBatteryDiffEntry(
long foregroundUsageTimeInMs, long backgroundUsageTimeInMs) { long foregroundUsageTimeInMs, long foregroundServiceUsageTimeInMs,
long backgroundUsageTimeInMs) {
return new BatteryDiffEntry( return new BatteryDiffEntry(
mContext, foregroundUsageTimeInMs, backgroundUsageTimeInMs, mContext, foregroundUsageTimeInMs, foregroundServiceUsageTimeInMs,
/*consumePower=*/ 0, mBatteryHistEntry); backgroundUsageTimeInMs, /*consumePower=*/ 0, /*foregroundUsageConsumePower=*/ 0,
/*foregroundServiceUsageConsumePower=*/ 0, /*backgroundUsageConsumePower=*/ 0,
/*cachedUsageConsumePower=*/ 0, mBatteryHistEntry);
} }
private BatteryChartPreferenceController createController() { private BatteryChartPreferenceController createController() {

20
tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryDiffEntryTest.java
View File

@@ -96,8 +96,13 @@ public final class BatteryDiffEntryTest {
new BatteryDiffEntry( new BatteryDiffEntry(
mContext, mContext,
/*foregroundUsageTimeInMs=*/ 10001L, /*foregroundUsageTimeInMs=*/ 10001L,
/*foregroundServiceUsageTimeInMs=*/ 10002L,
/*backgroundUsageTimeInMs=*/ 20002L, /*backgroundUsageTimeInMs=*/ 20002L,
/*consumePower=*/ 22.0, /*consumePower=*/ 22.0,
/*foregroundUsageConsumePower=*/ 10.0,
/*foregroundServiceUsageConsumePower=*/ 10.0,
/*backgroundUsageConsumePower=*/ 1.0,
/*cachedUsageConsumePower=*/ 1.0,
/*batteryHistEntry=*/ null); /*batteryHistEntry=*/ null);
entry.setTotalConsumePower(100.0); entry.setTotalConsumePower(100.0);
@@ -110,8 +115,13 @@ public final class BatteryDiffEntryTest {
new BatteryDiffEntry( new BatteryDiffEntry(
mContext, mContext,
/*foregroundUsageTimeInMs=*/ 10001L, /*foregroundUsageTimeInMs=*/ 10001L,
/*foregroundServiceUsageTimeInMs=*/ 10002L,
/*backgroundUsageTimeInMs=*/ 20002L, /*backgroundUsageTimeInMs=*/ 20002L,
/*consumePower=*/ 22.0, /*consumePower=*/ 22.0,
/*foregroundUsageConsumePower=*/ 10.0,
/*foregroundServiceUsageConsumePower=*/ 10.0,
/*backgroundUsageConsumePower=*/ 1.0,
/*cachedUsageConsumePower=*/ 1.0,
/*batteryHistEntry=*/ null); /*batteryHistEntry=*/ null);
entry.setTotalConsumePower(0); entry.setTotalConsumePower(0);
@@ -483,8 +493,13 @@ public final class BatteryDiffEntryTest {
return new BatteryDiffEntry( return new BatteryDiffEntry(
mContext, mContext,
/*foregroundUsageTimeInMs=*/ 0, /*foregroundUsageTimeInMs=*/ 0,
/*foregroundServiceUsageTimeInMs=*/ 0,
/*backgroundUsageTimeInMs=*/ 0, /*backgroundUsageTimeInMs=*/ 0,
/*consumePower=*/ 0, /*consumePower=*/ 0,
/*foregroundUsageConsumePower=*/ 0,
/*foregroundServiceUsageConsumePower=*/ 0,
/*backgroundUsageConsumePower=*/ 0,
/*cachedUsageConsumePower=*/ 0,
new BatteryHistEntry(values)); new BatteryHistEntry(values));
} }
@@ -493,8 +508,13 @@ public final class BatteryDiffEntryTest {
final BatteryDiffEntry entry = new BatteryDiffEntry( final BatteryDiffEntry entry = new BatteryDiffEntry(
mContext, mContext,
/*foregroundUsageTimeInMs=*/ 0, /*foregroundUsageTimeInMs=*/ 0,
/*foregroundServiceUsageTimeInMs=*/ 0,
/*backgroundUsageTimeInMs=*/ 0, /*backgroundUsageTimeInMs=*/ 0,
consumePower, consumePower,
/*foregroundUsageConsumePower=*/ 0,
/*foregroundServiceUsageConsumePower=*/ 0,
/*backgroundUsageConsumePower=*/ 0,
/*cachedUsageConsumePower=*/ 0,
batteryHistEntry); batteryHistEntry);
entry.setTotalConsumePower(100.0); entry.setTotalConsumePower(100.0);
return entry; return entry;

63
tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryHistEntryTest.java
View File

@@ -57,8 +57,13 @@ public final class BatteryHistEntryTest {
when(mMockBatteryEntry.isHidden()).thenReturn(true); when(mMockBatteryEntry.isHidden()).thenReturn(true);
when(mBatteryUsageStats.getConsumedPower()).thenReturn(5.1); when(mBatteryUsageStats.getConsumedPower()).thenReturn(5.1);
when(mMockBatteryEntry.getConsumedPower()).thenReturn(1.1); when(mMockBatteryEntry.getConsumedPower()).thenReturn(1.1);
when(mMockBatteryEntry.getConsumedPowerInForeground()).thenReturn(1.2);
when(mMockBatteryEntry.getConsumedPowerInForegroundService()).thenReturn(1.3);
when(mMockBatteryEntry.getConsumedPowerInBackground()).thenReturn(1.4);
when(mMockBatteryEntry.getConsumedPowerInCached()).thenReturn(1.5);
mMockBatteryEntry.mPercent = 0.3; mMockBatteryEntry.mPercent = 0.3;
when(mMockBatteryEntry.getTimeInForegroundMs()).thenReturn(1234L); when(mMockBatteryEntry.getTimeInForegroundMs()).thenReturn(1234L);
when(mMockBatteryEntry.getTimeInForegroundServiceMs()).thenReturn(3456L);
when(mMockBatteryEntry.getTimeInBackgroundMs()).thenReturn(5689L); when(mMockBatteryEntry.getTimeInBackgroundMs()).thenReturn(5689L);
when(mMockBatteryEntry.getPowerComponentId()).thenReturn(expectedType); when(mMockBatteryEntry.getPowerComponentId()).thenReturn(expectedType);
when(mMockBatteryEntry.getConsumerType()) when(mMockBatteryEntry.getConsumerType())
@@ -94,7 +99,12 @@ public final class BatteryHistEntryTest {
/*timestamp=*/ 10001L, /*timestamp=*/ 10001L,
/*totalPower=*/ 5.1, /*totalPower=*/ 5.1,
/*consumePower=*/ 1.1, /*consumePower=*/ 1.1,
/*foregroundUsageConsumePower=*/ 1.2,
/*foregroundServiceUsageConsumePower=*/ 1.3,
/*backgroundUsageConsumePower=*/ 1.4,
/*cachedUsageConsumePower=*/ 1.5,
/*foregroundUsageTimeInMs=*/ 1234L, /*foregroundUsageTimeInMs=*/ 1234L,
/*foregroundServiceUsageTimeInMs=*/ 3456L,
/*backgroundUsageTimeInMs=*/ 5689L, /*backgroundUsageTimeInMs=*/ 5689L,
/*batteryLevel=*/ 12), /*batteryLevel=*/ 12),
/*drainType=*/ 3, /*drainType=*/ 3,
@@ -178,7 +188,12 @@ public final class BatteryHistEntryTest {
lowerTimestamp, lowerTimestamp,
/*totalPower=*/ 50, /*totalPower=*/ 50,
/*consumePower=*/ 10, /*consumePower=*/ 10,
/*foregroundUsageConsumePower=*/ 1,
/*foregroundServiceUsageConsumePower=*/ 2,
/*backgroundUsageConsumePower=*/ 3,
/*cachedUsageConsumePower=*/ 4,
/*foregroundUsageTimeInMs=*/ 100, /*foregroundUsageTimeInMs=*/ 100,
/*foregroundServiceUsageTimeInMs=*/ 150,
/*backgroundUsageTimeInMs=*/ 200, /*backgroundUsageTimeInMs=*/ 200,
/*batteryLevel=*/ 90); /*batteryLevel=*/ 90);
final BatteryHistEntry upperHistEntry = createBatteryHistEntry( final BatteryHistEntry upperHistEntry = createBatteryHistEntry(
@@ -186,7 +201,12 @@ public final class BatteryHistEntryTest {
upperTimestamp, upperTimestamp,
/*totalPower=*/ 80, /*totalPower=*/ 80,
/*consumePower=*/ 20, /*consumePower=*/ 20,
/*foregroundUsageConsumePower=*/ 4,
/*foregroundServiceUsageConsumePower=*/ 5,
/*backgroundUsageConsumePower=*/ 6,
/*cachedUsageConsumePower=*/ 5,
/*foregroundUsageTimeInMs=*/ 200, /*foregroundUsageTimeInMs=*/ 200,
/*foregroundServiceUsageTimeInMs=*/ 250,
/*backgroundUsageTimeInMs=*/ 300, /*backgroundUsageTimeInMs=*/ 300,
/*batteryLevel=*/ 80); /*batteryLevel=*/ 80);
@@ -204,7 +224,12 @@ public final class BatteryHistEntryTest {
/*timestamp=*/ slotTimestamp, /*timestamp=*/ slotTimestamp,
/*totalPower=*/ 50 + 0.5 * (80 - 50), /*totalPower=*/ 50 + 0.5 * (80 - 50),
/*consumePower=*/ 10 + 0.5 * (20 - 10), /*consumePower=*/ 10 + 0.5 * (20 - 10),
/*foregroundUsageConsumePower=*/ 1 + 0.5 * (4 - 1),
/*foregroundServiceUsageConsumePower=*/ 2 + 0.5 * (5 - 2),
/*backgroundUsageConsumePower=*/ 3 + 0.5 * (6 - 3),
/*cachedUsageConsumePower=*/ 4 + 0.5 * (5 - 4),
/*foregroundUsageTimeInMs=*/ Math.round(100 + 0.5 * (200 - 100)), /*foregroundUsageTimeInMs=*/ Math.round(100 + 0.5 * (200 - 100)),
/*foregroundServiceUsageTimeInMs=*/ Math.round(150 + 0.5 * (250 - 150)),
/*backgroundUsageTimeInMs=*/ Math.round(200 + 0.5 * (300 - 200)), /*backgroundUsageTimeInMs=*/ Math.round(200 + 0.5 * (300 - 200)),
/*batteryLevel=*/ (int) Math.round(90 + 0.5 * (80 - 90))); /*batteryLevel=*/ (int) Math.round(90 + 0.5 * (80 - 90)));
} }
@@ -213,14 +238,18 @@ public final class BatteryHistEntryTest {
public void testInterpolate_withoutLowerEntryData_returnExpectedResult() { public void testInterpolate_withoutLowerEntryData_returnExpectedResult() {
final long slotTimestamp = 200L; final long slotTimestamp = 200L;
final long upperTimestamp = 300L; final long upperTimestamp = 300L;
final long lowerTimestamp = 100L;
final double ratio = 0.5; final double ratio = 0.5;
final BatteryHistEntry upperHistEntry = createBatteryHistEntry( final BatteryHistEntry upperHistEntry = createBatteryHistEntry(
/*bootTimestamp=*/ 1200L, /*bootTimestamp=*/ 1200L,
upperTimestamp, upperTimestamp,
/*totalPower=*/ 80, /*totalPower=*/ 80,
/*consumePower=*/ 20, /*consumePower=*/ 20,
/*foregroundUsageConsumePower=*/ 4,
/*foregroundServiceUsageConsumePower=*/ 5,
/*backgroundUsageConsumePower=*/ 6,
/*cachedUsageConsumePower=*/ 5,
/*foregroundUsageTimeInMs=*/ 200, /*foregroundUsageTimeInMs=*/ 200,
/*foregroundServiceUsageTimeInMs=*/ 250,
/*backgroundUsageTimeInMs=*/ 300, /*backgroundUsageTimeInMs=*/ 300,
/*batteryLevel=*/ 80); /*batteryLevel=*/ 80);
@@ -238,7 +267,12 @@ public final class BatteryHistEntryTest {
/*timestamp=*/ slotTimestamp, /*timestamp=*/ slotTimestamp,
/*totalPower=*/ 0.5 * 80, /*totalPower=*/ 0.5 * 80,
/*consumePower=*/ 0.5 * 20, /*consumePower=*/ 0.5 * 20,
/*foregroundUsageConsumePower=*/ 0.5 * 4,
/*foregroundServiceUsageConsumePower=*/ 0.5 * 5,
/*backgroundUsageConsumePower=*/ 0.5 * 6,
/*cachedUsageConsumePower=*/ 0.5 * 5,
/*foregroundUsageTimeInMs=*/ Math.round(0.5 * 200), /*foregroundUsageTimeInMs=*/ Math.round(0.5 * 200),
/*foregroundServiceUsageTimeInMs=*/ Math.round(0.5 * 250),
/*backgroundUsageTimeInMs=*/ Math.round(0.5 * 300), /*backgroundUsageTimeInMs=*/ Math.round(0.5 * 300),
/*batteryLevel=*/ upperHistEntry.mBatteryLevel); /*batteryLevel=*/ upperHistEntry.mBatteryLevel);
} }
@@ -262,7 +296,12 @@ public final class BatteryHistEntryTest {
/*timestamp=*/ 10001L, /*timestamp=*/ 10001L,
/*totalPower=*/ 5.1, /*totalPower=*/ 5.1,
/*consumePower=*/ 1.1, /*consumePower=*/ 1.1,
/*foregroundUsageConsumePower=*/ 1.2,
/*foregroundServiceUsageConsumePower=*/ 1.3,
/*backgroundUsageConsumePower=*/ 1.4,
/*cachedUsageConsumePower=*/ 1.5,
/*foregroundUsageTimeInMs=*/ 1234L, /*foregroundUsageTimeInMs=*/ 1234L,
/*foregroundServiceUsageTimeInMs=*/ 3456L,
/*backgroundUsageTimeInMs=*/ 5689L, /*backgroundUsageTimeInMs=*/ 5689L,
/*batteryLevel=*/ 12); /*batteryLevel=*/ 12);
} }
@@ -275,7 +314,12 @@ public final class BatteryHistEntryTest {
long timestamp, long timestamp,
double totalPower, double totalPower,
double consumePower, double consumePower,
double foregroundUsageConsumePower,
double foregroundServiceUsageConsumePower,
double backgroundUsageConsumePower,
double cachedUsageConsumePower,
long foregroundUsageTimeInMs, long foregroundUsageTimeInMs,
long foregroundServiceUsageTimeInMs,
long backgroundUsageTimeInMs, long backgroundUsageTimeInMs,
int batteryLevel) { int batteryLevel) {
assertThat(entry.isValidEntry()).isTrue(); assertThat(entry.isValidEntry()).isTrue();
@@ -290,8 +334,15 @@ public final class BatteryHistEntryTest {
assertThat(entry.mZoneId).isEqualTo(TimeZone.getDefault().getID()); assertThat(entry.mZoneId).isEqualTo(TimeZone.getDefault().getID());
assertThat(entry.mTotalPower).isEqualTo(totalPower); assertThat(entry.mTotalPower).isEqualTo(totalPower);
assertThat(entry.mConsumePower).isEqualTo(consumePower); assertThat(entry.mConsumePower).isEqualTo(consumePower);
assertThat(entry.mForegroundUsageConsumePower).isEqualTo(foregroundUsageConsumePower);
assertThat(entry.mForegroundServiceUsageConsumePower)
.isEqualTo(foregroundServiceUsageConsumePower);
assertThat(entry.mBackgroundUsageConsumePower).isEqualTo(backgroundUsageConsumePower);
assertThat(entry.mCachedUsageConsumePower).isEqualTo(cachedUsageConsumePower);
assertThat(entry.mPercentOfTotal).isEqualTo(percentOfTotal); assertThat(entry.mPercentOfTotal).isEqualTo(percentOfTotal);
assertThat(entry.mForegroundUsageTimeInMs).isEqualTo(foregroundUsageTimeInMs); assertThat(entry.mForegroundUsageTimeInMs).isEqualTo(foregroundUsageTimeInMs);
assertThat(entry.mForegroundServiceUsageTimeInMs)
.isEqualTo(foregroundServiceUsageTimeInMs);
assertThat(entry.mBackgroundUsageTimeInMs).isEqualTo(backgroundUsageTimeInMs); assertThat(entry.mBackgroundUsageTimeInMs).isEqualTo(backgroundUsageTimeInMs);
assertThat(entry.mDrainType).isEqualTo(drainType); assertThat(entry.mDrainType).isEqualTo(drainType);
assertThat(entry.mConsumerType) assertThat(entry.mConsumerType)
@@ -308,7 +359,12 @@ public final class BatteryHistEntryTest {
long timestamp, long timestamp,
double totalPower, double totalPower,
double consumePower, double consumePower,
double foregroundUsageConsumePower,
double foregroundServiceUsageConsumePower,
double backgroundUsageConsumePower,
double cachedUsageConsumePower,
long foregroundUsageTimeInMs, long foregroundUsageTimeInMs,
long foregroundServiceUsageTimeInMs,
long backgroundUsageTimeInMs, long backgroundUsageTimeInMs,
int batteryLevel) { int batteryLevel) {
final MatrixCursor cursor = new MatrixCursor( final MatrixCursor cursor = new MatrixCursor(
@@ -336,9 +392,14 @@ public final class BatteryHistEntryTest {
.setAppLabel("Settings") .setAppLabel("Settings")
.setTotalPower(totalPower) .setTotalPower(totalPower)
.setConsumePower(consumePower) .setConsumePower(consumePower)
.setForegroundUsageConsumePower(foregroundUsageConsumePower)
.setForegroundServiceUsageConsumePower(foregroundServiceUsageConsumePower)
.setBackgroundUsageConsumePower(backgroundUsageConsumePower)
.setCachedUsageConsumePower(cachedUsageConsumePower)
.setPercentOfTotal(0.3) .setPercentOfTotal(0.3)
.setDrainType(3) .setDrainType(3)
.setForegroundUsageTimeInMs(foregroundUsageTimeInMs) .setForegroundUsageTimeInMs(foregroundUsageTimeInMs)
.setForegroundServiceUsageTimeInMs(foregroundServiceUsageTimeInMs)
.setBackgroundUsageTimeInMs(backgroundUsageTimeInMs) .setBackgroundUsageTimeInMs(backgroundUsageTimeInMs)
.build(); .build();
cursor.addRow( cursor.addRow(

5
tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryUsageContentProviderTest.java
View File

@@ -196,8 +196,13 @@ public final class BatteryUsageContentProviderTest {
.setBootTimestamp(101L) .setBootTimestamp(101L)
.setTotalPower(99) .setTotalPower(99)
.setConsumePower(9) .setConsumePower(9)
.setForegroundUsageConsumePower(1)
.setForegroundServiceUsageConsumePower(2)
.setBackgroundUsageConsumePower(3)
.setCachedUsageConsumePower(3)
.setPercentOfTotal(0.9) .setPercentOfTotal(0.9)
.setForegroundUsageTimeInMs(1000) .setForegroundUsageTimeInMs(1000)
.setForegroundServiceUsageTimeInMs(1500)
.setBackgroundUsageTimeInMs(2000) .setBackgroundUsageTimeInMs(2000)
.setDrainType(1) .setDrainType(1)
.build(); .build();

334
tests/robotests/src/com/android/settings/fuelgauge/batteryusage/ConvertUtilsTest.java
View File

@@ -26,11 +26,6 @@ import android.os.BatteryManager;
import android.os.BatteryUsageStats; import android.os.BatteryUsageStats;
import android.os.LocaleList; import android.os.LocaleList;
import android.os.UserHandle; import android.os.UserHandle;
import android.text.format.DateUtils;
import com.android.settings.fuelgauge.BatteryUtils;
import com.android.settings.fuelgauge.PowerUsageFeatureProvider;
import com.android.settings.testutils.FakeFeatureFactory;
import org.junit.Before; import org.junit.Before;
import org.junit.Test; import org.junit.Test;
@@ -40,13 +35,7 @@ import org.mockito.MockitoAnnotations;
import org.robolectric.RobolectricTestRunner; import org.robolectric.RobolectricTestRunner;
import org.robolectric.RuntimeEnvironment; import org.robolectric.RuntimeEnvironment;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Locale; import java.util.Locale;
import java.util.Map;
import java.util.TimeZone; import java.util.TimeZone;
@RunWith(RobolectricTestRunner.class) @RunWith(RobolectricTestRunner.class)
@@ -59,15 +48,10 @@ public final class ConvertUtilsTest {
@Mock @Mock
private BatteryEntry mMockBatteryEntry; private BatteryEntry mMockBatteryEntry;
private FakeFeatureFactory mFeatureFactory;
private PowerUsageFeatureProvider mPowerUsageFeatureProvider;
@Before @Before
public void setUp() { public void setUp() {
MockitoAnnotations.initMocks(this); MockitoAnnotations.initMocks(this);
mContext = spy(RuntimeEnvironment.application); mContext = spy(RuntimeEnvironment.application);
mFeatureFactory = FakeFeatureFactory.setupForTest();
mPowerUsageFeatureProvider = mFeatureFactory.powerUsageFeatureProvider;
} }
@Test @Test
@@ -80,8 +64,13 @@ public final class ConvertUtilsTest {
when(mMockBatteryEntry.isHidden()).thenReturn(true); when(mMockBatteryEntry.isHidden()).thenReturn(true);
when(mBatteryUsageStats.getConsumedPower()).thenReturn(5.1); when(mBatteryUsageStats.getConsumedPower()).thenReturn(5.1);
when(mMockBatteryEntry.getConsumedPower()).thenReturn(1.1); when(mMockBatteryEntry.getConsumedPower()).thenReturn(1.1);
when(mMockBatteryEntry.getConsumedPowerInForeground()).thenReturn(1.2);
when(mMockBatteryEntry.getConsumedPowerInForegroundService()).thenReturn(1.3);
when(mMockBatteryEntry.getConsumedPowerInBackground()).thenReturn(1.4);
when(mMockBatteryEntry.getConsumedPowerInCached()).thenReturn(1.5);
mMockBatteryEntry.mPercent = 0.3; mMockBatteryEntry.mPercent = 0.3;
when(mMockBatteryEntry.getTimeInForegroundMs()).thenReturn(1234L); when(mMockBatteryEntry.getTimeInForegroundMs()).thenReturn(1234L);
when(mMockBatteryEntry.getTimeInForegroundServiceMs()).thenReturn(3456L);
when(mMockBatteryEntry.getTimeInBackgroundMs()).thenReturn(5689L); when(mMockBatteryEntry.getTimeInBackgroundMs()).thenReturn(5689L);
when(mMockBatteryEntry.getPowerComponentId()).thenReturn(expectedType); when(mMockBatteryEntry.getPowerComponentId()).thenReturn(expectedType);
when(mMockBatteryEntry.getConsumerType()) when(mMockBatteryEntry.getConsumerType())
@@ -117,8 +106,13 @@ public final class ConvertUtilsTest {
assertThat(batteryInformation.getZoneId()).isEqualTo(TimeZone.getDefault().getID()); assertThat(batteryInformation.getZoneId()).isEqualTo(TimeZone.getDefault().getID());
assertThat(batteryInformation.getTotalPower()).isEqualTo(5.1); assertThat(batteryInformation.getTotalPower()).isEqualTo(5.1);
assertThat(batteryInformation.getConsumePower()).isEqualTo(1.1); assertThat(batteryInformation.getConsumePower()).isEqualTo(1.1);
assertThat(batteryInformation.getForegroundUsageConsumePower()).isEqualTo(1.2);
assertThat(batteryInformation.getForegroundServiceUsageConsumePower()).isEqualTo(1.3);
assertThat(batteryInformation.getBackgroundUsageConsumePower()).isEqualTo(1.4);
assertThat(batteryInformation.getCachedUsageConsumePower()).isEqualTo(1.5);
assertThat(batteryInformation.getPercentOfTotal()).isEqualTo(0.3); assertThat(batteryInformation.getPercentOfTotal()).isEqualTo(0.3);
assertThat(batteryInformation.getForegroundUsageTimeInMs()).isEqualTo(1234L); assertThat(batteryInformation.getForegroundUsageTimeInMs()).isEqualTo(1234L);
assertThat(batteryInformation.getForegroundServiceUsageTimeInMs()).isEqualTo(3456L);
assertThat(batteryInformation.getBackgroundUsageTimeInMs()).isEqualTo(5689L); assertThat(batteryInformation.getBackgroundUsageTimeInMs()).isEqualTo(5689L);
assertThat(batteryInformation.getDrainType()).isEqualTo(expectedType); assertThat(batteryInformation.getDrainType()).isEqualTo(expectedType);
assertThat(deviceBatteryState.getBatteryLevel()).isEqualTo(12); assertThat(deviceBatteryState.getBatteryLevel()).isEqualTo(12);
@@ -169,8 +163,13 @@ public final class ConvertUtilsTest {
when(mMockBatteryEntry.isHidden()).thenReturn(true); when(mMockBatteryEntry.isHidden()).thenReturn(true);
when(mBatteryUsageStats.getConsumedPower()).thenReturn(5.1); when(mBatteryUsageStats.getConsumedPower()).thenReturn(5.1);
when(mMockBatteryEntry.getConsumedPower()).thenReturn(1.1); when(mMockBatteryEntry.getConsumedPower()).thenReturn(1.1);
when(mMockBatteryEntry.getConsumedPowerInForeground()).thenReturn(1.2);
when(mMockBatteryEntry.getConsumedPowerInForegroundService()).thenReturn(1.3);
when(mMockBatteryEntry.getConsumedPowerInBackground()).thenReturn(1.4);
when(mMockBatteryEntry.getConsumedPowerInCached()).thenReturn(1.5);
mMockBatteryEntry.mPercent = 0.3; mMockBatteryEntry.mPercent = 0.3;
when(mMockBatteryEntry.getTimeInForegroundMs()).thenReturn(1234L); when(mMockBatteryEntry.getTimeInForegroundMs()).thenReturn(1234L);
when(mMockBatteryEntry.getTimeInForegroundServiceMs()).thenReturn(3456L);
when(mMockBatteryEntry.getTimeInBackgroundMs()).thenReturn(5689L); when(mMockBatteryEntry.getTimeInBackgroundMs()).thenReturn(5689L);
when(mMockBatteryEntry.getPowerComponentId()).thenReturn(expectedType); when(mMockBatteryEntry.getPowerComponentId()).thenReturn(expectedType);
when(mMockBatteryEntry.getConsumerType()) when(mMockBatteryEntry.getConsumerType())
@@ -196,9 +195,15 @@ public final class ConvertUtilsTest {
.isEqualTo(TimeZone.getDefault().getID()); .isEqualTo(TimeZone.getDefault().getID());
assertThat(batteryHistEntry.mTotalPower).isEqualTo(5.1); assertThat(batteryHistEntry.mTotalPower).isEqualTo(5.1);
assertThat(batteryHistEntry.mConsumePower).isEqualTo(1.1); assertThat(batteryHistEntry.mConsumePower).isEqualTo(1.1);
assertThat(batteryHistEntry.mForegroundUsageConsumePower).isEqualTo(1.2);
assertThat(batteryHistEntry.mForegroundServiceUsageConsumePower).isEqualTo(1.3);
assertThat(batteryHistEntry.mBackgroundUsageConsumePower).isEqualTo(1.4);
assertThat(batteryHistEntry.mCachedUsageConsumePower).isEqualTo(1.5);
assertThat(batteryHistEntry.mPercentOfTotal).isEqualTo(0.3); assertThat(batteryHistEntry.mPercentOfTotal).isEqualTo(0.3);
assertThat(batteryHistEntry.mForegroundUsageTimeInMs) assertThat(batteryHistEntry.mForegroundUsageTimeInMs)
.isEqualTo(1234L); .isEqualTo(1234L);
assertThat(batteryHistEntry.mForegroundServiceUsageTimeInMs)
.isEqualTo(3456L);
assertThat(batteryHistEntry.mBackgroundUsageTimeInMs) assertThat(batteryHistEntry.mBackgroundUsageTimeInMs)
.isEqualTo(5689L); .isEqualTo(5689L);
assertThat(batteryHistEntry.mDrainType).isEqualTo(expectedType); assertThat(batteryHistEntry.mDrainType).isEqualTo(expectedType);
@@ -229,194 +234,6 @@ public final class ConvertUtilsTest {
.isEqualTo(ConvertUtils.FAKE_PACKAGE_NAME); .isEqualTo(ConvertUtils.FAKE_PACKAGE_NAME);
} }
@Test
public void getIndexedUsageMap_nullOrEmptyHistoryMap_returnEmptyCollection() {
final int timeSlotSize = 2;
final long[] batteryHistoryKeys = new long[]{101L, 102L, 103L, 104L, 105L};
assertThat(ConvertUtils.getIndexedUsageMap(
mContext, timeSlotSize, batteryHistoryKeys,
/*batteryHistoryMap=*/ null, /*purgeLowPercentageAndFakeData=*/ true))
.isEmpty();
assertThat(ConvertUtils.getIndexedUsageMap(
mContext, timeSlotSize, batteryHistoryKeys,
new HashMap<Long, Map<String, BatteryHistEntry>>(),
/*purgeLowPercentageAndFakeData=*/ true))
.isEmpty();
}
@Test
public void getIndexedUsageMap_returnsExpectedResult() {
// Creates the fake testing data.
final int timeSlotSize = 2;
final long[] batteryHistoryKeys = new long[]{generateTimestamp(0), generateTimestamp(1),
generateTimestamp(2), generateTimestamp(3), generateTimestamp(4)};
final Map<Long, Map<String, BatteryHistEntry>> batteryHistoryMap =
new HashMap<>();
final BatteryHistEntry fakeEntry = createBatteryHistEntry(
ConvertUtils.FAKE_PACKAGE_NAME, "fake_label", 0, 0L, 0L, 0L);
// Adds the index = 0 data.
Map<String, BatteryHistEntry> entryMap = new HashMap<>();
BatteryHistEntry entry = createBatteryHistEntry(
"package1", "label1", 5.0, 1L, 10L, 20L);
entryMap.put(entry.getKey(), entry);
entryMap.put(fakeEntry.getKey(), fakeEntry);
batteryHistoryMap.put(Long.valueOf(batteryHistoryKeys[0]), entryMap);
// Adds the index = 1 data.
entryMap = new HashMap<>();
entryMap.put(fakeEntry.getKey(), fakeEntry);
batteryHistoryMap.put(Long.valueOf(batteryHistoryKeys[1]), entryMap);
// Adds the index = 2 data.
entryMap = new HashMap<>();
entry = createBatteryHistEntry(
"package2", "label2", 10.0, 2L, 15L, 25L);
entryMap.put(entry.getKey(), entry);
entryMap.put(fakeEntry.getKey(), fakeEntry);
batteryHistoryMap.put(Long.valueOf(batteryHistoryKeys[2]), entryMap);
// Adds the index = 3 data.
entryMap = new HashMap<>();
entry = createBatteryHistEntry(
"package2", "label2", 15.0, 2L, 25L, 35L);
entryMap.put(entry.getKey(), entry);
entry = createBatteryHistEntry(
"package3", "label3", 5.0, 3L, 5L, 5L);
entryMap.put(entry.getKey(), entry);
entryMap.put(fakeEntry.getKey(), fakeEntry);
batteryHistoryMap.put(Long.valueOf(batteryHistoryKeys[3]), entryMap);
// Adds the index = 4 data.
entryMap = new HashMap<>();
entry = createBatteryHistEntry(
"package2", "label2", 30.0, 2L, 30L, 40L);
entryMap.put(entry.getKey(), entry);
entry = createBatteryHistEntry(
"package2", "label2", 75.0, 4L, 40L, 50L);
entryMap.put(entry.getKey(), entry);
entry = createBatteryHistEntry(
"package3", "label3", 5.0, 3L, 5L, 5L);
entryMap.put(entry.getKey(), entry);
entryMap.put(fakeEntry.getKey(), fakeEntry);
batteryHistoryMap.put(Long.valueOf(batteryHistoryKeys[4]), entryMap);
final Map<Integer, List<BatteryDiffEntry>> resultMap =
ConvertUtils.getIndexedUsageMap(
mContext, timeSlotSize, batteryHistoryKeys, batteryHistoryMap,
/*purgeLowPercentageAndFakeData=*/ false);
assertThat(resultMap).hasSize(3);
// Verifies the first timestamp result.
List<BatteryDiffEntry> entryList = resultMap.get(Integer.valueOf(0));
assertThat(entryList).hasSize(1);
assertBatteryDiffEntry(entryList.get(0), 100, 15L, 25L);
// Verifies the second timestamp result.
entryList = resultMap.get(Integer.valueOf(1));
assertThat(entryList).hasSize(3);
assertBatteryDiffEntry(entryList.get(1), 5, 5L, 5L);
assertBatteryDiffEntry(entryList.get(2), 75, 40L, 50L);
assertBatteryDiffEntry(entryList.get(0), 20, 15L, 15L);
// Verifies the last 24 hours aggregate result.
entryList = resultMap.get(Integer.valueOf(-1));
assertThat(entryList).hasSize(3);
assertBatteryDiffEntry(entryList.get(1), 4, 5L, 5L);
assertBatteryDiffEntry(entryList.get(2), 68, 40L, 50L);
assertBatteryDiffEntry(entryList.get(0), 27, 30L, 40L);
// Test getIndexedUsageMap() with purged data.
ConvertUtils.PERCENTAGE_OF_TOTAL_THRESHOLD = 50;
final Map<Integer, List<BatteryDiffEntry>> purgedResultMap =
ConvertUtils.getIndexedUsageMap(
mContext, timeSlotSize, batteryHistoryKeys, batteryHistoryMap,
/*purgeLowPercentageAndFakeData=*/ true);
assertThat(purgedResultMap).hasSize(3);
// Verifies the first timestamp result.
entryList = purgedResultMap.get(Integer.valueOf(0));
assertThat(entryList).hasSize(1);
// Verifies the second timestamp result.
entryList = purgedResultMap.get(Integer.valueOf(1));
assertThat(entryList).hasSize(1);
assertBatteryDiffEntry(entryList.get(0), 75, 40L, 50L);
// Verifies the last 24 hours aggregate result.
entryList = purgedResultMap.get(Integer.valueOf(-1));
assertThat(entryList).hasSize(1);
// Verifies the fake data is cleared out.
assertThat(entryList.get(0).getPackageName())
.isNotEqualTo(ConvertUtils.FAKE_PACKAGE_NAME);
}
@Test
public void getIndexedUsageMap_usageTimeExceed_returnsExpectedResult() {
final int timeSlotSize = 1;
final long[] batteryHistoryKeys = new long[]{101L, 102L, 103L};
final Map<Long, Map<String, BatteryHistEntry>> batteryHistoryMap =
new HashMap<>();
final BatteryHistEntry fakeEntry = createBatteryHistEntry(
ConvertUtils.FAKE_PACKAGE_NAME, "fake_label", 0, 0L, 0L, 0L);
// Adds the index = 0 data.
Map<String, BatteryHistEntry> entryMap = new HashMap<>();
entryMap.put(fakeEntry.getKey(), fakeEntry);
batteryHistoryMap.put(Long.valueOf(batteryHistoryKeys[0]), entryMap);
// Adds the index = 1 data.
entryMap = new HashMap<>();
entryMap.put(fakeEntry.getKey(), fakeEntry);
batteryHistoryMap.put(Long.valueOf(batteryHistoryKeys[1]), entryMap);
// Adds the index = 2 data.
entryMap = new HashMap<>();
final BatteryHistEntry entry = createBatteryHistEntry(
"package3", "label3", 500, 5L, 3600000L, 7200000L);
entryMap.put(entry.getKey(), entry);
batteryHistoryMap.put(Long.valueOf(batteryHistoryKeys[2]), entryMap);
final Map<Integer, List<BatteryDiffEntry>> purgedResultMap =
ConvertUtils.getIndexedUsageMap(
mContext, timeSlotSize, batteryHistoryKeys, batteryHistoryMap,
/*purgeLowPercentageAndFakeData=*/ true);
assertThat(purgedResultMap).hasSize(2);
final List<BatteryDiffEntry> entryList = purgedResultMap.get(0);
assertThat(entryList).hasSize(1);
// Verifies the clipped usage time.
final float ratio = (float) (7200) / (float) (3600 + 7200);
final BatteryDiffEntry resultEntry = entryList.get(0);
assertThat(resultEntry.mForegroundUsageTimeInMs)
.isEqualTo(Math.round(entry.mForegroundUsageTimeInMs * ratio));
assertThat(resultEntry.mBackgroundUsageTimeInMs)
.isEqualTo(Math.round(entry.mBackgroundUsageTimeInMs * ratio));
assertThat(resultEntry.mConsumePower)
.isEqualTo(entry.mConsumePower * ratio);
}
@Test
public void getIndexedUsageMap_hideBackgroundUsageTime_returnsExpectedResult() {
final long[] batteryHistoryKeys = new long[]{101L, 102L, 103L};
final Map<Long, Map<String, BatteryHistEntry>> batteryHistoryMap = new HashMap<>();
final BatteryHistEntry fakeEntry = createBatteryHistEntry(
ConvertUtils.FAKE_PACKAGE_NAME, "fake_label", 0, 0L, 0L, 0L);
// Adds the index = 0 data.
Map<String, BatteryHistEntry> entryMap = new HashMap<>();
entryMap.put(fakeEntry.getKey(), fakeEntry);
batteryHistoryMap.put(Long.valueOf(batteryHistoryKeys[0]), entryMap);
// Adds the index = 1 data.
entryMap = new HashMap<>();
entryMap.put(fakeEntry.getKey(), fakeEntry);
batteryHistoryMap.put(Long.valueOf(batteryHistoryKeys[1]), entryMap);
// Adds the index = 2 data.
entryMap = new HashMap<>();
final BatteryHistEntry entry = createBatteryHistEntry(
"package3", "label3", 500, 5L, 3600000L, 7200000L);
entryMap.put(entry.getKey(), entry);
batteryHistoryMap.put(Long.valueOf(batteryHistoryKeys[2]), entryMap);
when(mPowerUsageFeatureProvider.getHideBackgroundUsageTimeSet(mContext))
.thenReturn(new HashSet(Arrays.asList((CharSequence) "package3")));
final Map<Integer, List<BatteryDiffEntry>> purgedResultMap =
ConvertUtils.getIndexedUsageMap(
mContext, /*timeSlotSize=*/ 1, batteryHistoryKeys, batteryHistoryMap,
/*purgeLowPercentageAndFakeData=*/ true);
final BatteryDiffEntry resultEntry = purgedResultMap.get(0).get(0);
assertThat(resultEntry.mBackgroundUsageTimeInMs).isEqualTo(0);
}
@Test @Test
public void getLocale_nullContext_returnDefaultLocale() { public void getLocale_nullContext_returnDefaultLocale() {
assertThat(ConvertUtils.getLocale(/*context=*/ null)) assertThat(ConvertUtils.getLocale(/*context=*/ null))
@@ -434,113 +251,4 @@ public final class ConvertUtilsTest {
mContext.getResources().getConfiguration().setLocales(new LocaleList()); mContext.getResources().getConfiguration().setLocales(new LocaleList());
assertThat(ConvertUtils.getLocale(mContext)).isEqualTo(Locale.getDefault()); assertThat(ConvertUtils.getLocale(mContext)).isEqualTo(Locale.getDefault());
} }
@Test
public void resolveMultiUsersData_replaceOtherUsersItemWithExpectedEntry() {
final int currentUserId = mContext.getUserId();
final Map<Integer, List<BatteryDiffEntry>> entryMap = new HashMap<>();
// Without other users time slot.
entryMap.put(0, Arrays.asList(
createBatteryDiffEntry(
currentUserId,
ConvertUtils.CONSUMER_TYPE_UID_BATTERY,
/*consumePercentage=*/ 50)));
// With other users time slot.
final List<BatteryDiffEntry> withOtherUsersList = new ArrayList<>();
entryMap.put(1, withOtherUsersList);
withOtherUsersList.add(
createBatteryDiffEntry(
currentUserId + 1,
ConvertUtils.CONSUMER_TYPE_SYSTEM_BATTERY,
/*consumePercentage=*/ 20));
withOtherUsersList.add(
createBatteryDiffEntry(
currentUserId + 2,
ConvertUtils.CONSUMER_TYPE_UID_BATTERY,
/*consumePercentage=*/ 30));
withOtherUsersList.add(
createBatteryDiffEntry(
currentUserId + 3,
ConvertUtils.CONSUMER_TYPE_UID_BATTERY,
/*consumePercentage=*/ 40));
ConvertUtils.resolveMultiUsersData(mContext, entryMap);
assertThat(entryMap.get(0).get(0).getPercentOfTotal()).isEqualTo(50);
// Asserts with other users items.
final List<BatteryDiffEntry> entryList = entryMap.get(1);
assertThat(entryList).hasSize(2);
assertBatteryDiffEntry(
entryList.get(0),
currentUserId + 1,
/*uid=*/ 0,
ConvertUtils.CONSUMER_TYPE_SYSTEM_BATTERY,
/*consumePercentage=*/ 20);
assertBatteryDiffEntry(
entryList.get(1),
BatteryUtils.UID_OTHER_USERS,
BatteryUtils.UID_OTHER_USERS,
ConvertUtils.CONSUMER_TYPE_UID_BATTERY,
/*consumePercentage=*/ 70);
}
private BatteryDiffEntry createBatteryDiffEntry(
long userId, int counsumerType, double consumePercentage) {
final ContentValues values = new ContentValues();
values.put(BatteryHistEntry.KEY_USER_ID, userId);
values.put(BatteryHistEntry.KEY_CONSUMER_TYPE, counsumerType);
final BatteryDiffEntry batteryDiffEntry =
new BatteryDiffEntry(
mContext,
/*foregroundUsageTimeInMs=*/ 0,
/*backgroundUsageTimeInMs=*/ 0,
/*consumePower=*/ consumePercentage,
new BatteryHistEntry(values));
batteryDiffEntry.setTotalConsumePower(100f);
return batteryDiffEntry;
}
private static BatteryHistEntry createBatteryHistEntry(
String packageName, String appLabel, double consumePower,
long uid, long foregroundUsageTimeInMs, long backgroundUsageTimeInMs) {
// Only insert required fields.
final BatteryInformation batteryInformation =
BatteryInformation
.newBuilder()
.setAppLabel(appLabel)
.setConsumePower(consumePower)
.setForegroundUsageTimeInMs(foregroundUsageTimeInMs)
.setBackgroundUsageTimeInMs(backgroundUsageTimeInMs)
.build();
final ContentValues values = new ContentValues();
values.put(BatteryHistEntry.KEY_PACKAGE_NAME, packageName);
values.put(BatteryHistEntry.KEY_UID, Long.valueOf(uid));
values.put(BatteryHistEntry.KEY_CONSUMER_TYPE,
Integer.valueOf(ConvertUtils.CONSUMER_TYPE_UID_BATTERY));
values.put(BatteryHistEntry.KEY_BATTERY_INFORMATION,
ConvertUtils.convertBatteryInformationToString(batteryInformation));
return new BatteryHistEntry(values);
}
private static void assertBatteryDiffEntry(
BatteryDiffEntry entry, long userId, long uid, int counsumerType,
double consumePercentage) {
assertThat(entry.mBatteryHistEntry.mUid).isEqualTo(uid);
assertThat(entry.mBatteryHistEntry.mUserId).isEqualTo(userId);
assertThat(entry.mBatteryHistEntry.mConsumerType).isEqualTo(counsumerType);
assertThat(entry.getPercentOfTotal()).isEqualTo(consumePercentage);
}
private static void assertBatteryDiffEntry(
BatteryDiffEntry entry, int percentOfTotal,
long foregroundUsageTimeInMs, long backgroundUsageTimeInMs) {
assertThat((int) entry.getPercentOfTotal()).isEqualTo(percentOfTotal);
assertThat(entry.mForegroundUsageTimeInMs).isEqualTo(foregroundUsageTimeInMs);
assertThat(entry.mBackgroundUsageTimeInMs).isEqualTo(backgroundUsageTimeInMs);
}
private static Long generateTimestamp(int index) {
// "2021-04-23 07:00:00 UTC" + index hours
return 1619247600000L + index * DateUtils.HOUR_IN_MILLIS;
}
} }

351
tests/robotests/src/com/android/settings/fuelgauge/batteryusage/DataProcessorTest.java
View File

@@ -532,15 +532,21 @@ public class DataProcessorTest {
final Map<Long, Map<String, BatteryHistEntry>> batteryHistoryMap = new HashMap<>(); final Map<Long, Map<String, BatteryHistEntry>> batteryHistoryMap = new HashMap<>();
final int currentUserId = mContext.getUserId(); final int currentUserId = mContext.getUserId();
final BatteryHistEntry fakeEntry = createBatteryHistEntry( final BatteryHistEntry fakeEntry = createBatteryHistEntry(
ConvertUtils.FAKE_PACKAGE_NAME, "fake_label", /*consumePower=*/ 0, /*uid=*/ 0L, ConvertUtils.FAKE_PACKAGE_NAME, "fake_label", /*consumePower=*/ 0,
currentUserId, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageConsumePower=*/ 0, /*foregroundServiceUsageConsumePower=*/ 0,
/*foregroundUsageTimeInMs=*/ 0L, /*backgroundUsageTimeInMs=*/ 0L); /*backgroundUsageConsumePower=*/ 0, /*cachedUsageConsumePower=*/ 0,
/*uid=*/ 0L, currentUserId, ConvertUtils.CONSUMER_TYPE_UID_BATTERY,
/*foregroundUsageTimeInMs=*/ 0L, /*foregroundServiceUsageTimeInMs=*/ 0L,
/*backgroundUsageTimeInMs=*/ 0L);
// Adds the index = 0 data. // Adds the index = 0 data.
Map<String, BatteryHistEntry> entryMap = new HashMap<>(); Map<String, BatteryHistEntry> entryMap = new HashMap<>();
BatteryHistEntry entry = createBatteryHistEntry( BatteryHistEntry entry = createBatteryHistEntry(
"package1", "label1", /*consumePower=*/ 5.0, /*uid=*/ 1L, currentUserId, "package1", "label1", /*consumePower=*/ 5.0,
/*foregroundUsageConsumePower=*/ 2, /*foregroundServiceUsageConsumePower=*/ 0,
/*backgroundUsageConsumePower=*/ 3, /*cachedUsageConsumePower=*/ 0,
/*uid=*/ 1L, currentUserId,
ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 10L, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 10L,
/*backgroundUsageTimeInMs=*/ 20L); /*foregroundServiceUsageTimeInMs=*/ 10L, /*backgroundUsageTimeInMs=*/ 20L);
entryMap.put(entry.getKey(), entry); entryMap.put(entry.getKey(), entry);
entryMap.put(fakeEntry.getKey(), fakeEntry); entryMap.put(fakeEntry.getKey(), fakeEntry);
batteryHistoryMap.put(batteryHistoryKeys[0], entryMap); batteryHistoryMap.put(batteryHistoryKeys[0], entryMap);
@@ -551,47 +557,68 @@ public class DataProcessorTest {
// Adds the index = 2 data. // Adds the index = 2 data.
entryMap = new HashMap<>(); entryMap = new HashMap<>();
entry = createBatteryHistEntry( entry = createBatteryHistEntry(
"package2", "label2", /*consumePower=*/ 20.0, /*uid=*/ 2L, currentUserId, "package2", "label2", /*consumePower=*/ 20.0,
/*foregroundUsageConsumePower=*/ 5, /*foregroundServiceUsageConsumePower=*/ 5,
/*backgroundUsageConsumePower=*/ 5, /*cachedUsageConsumePower=*/ 5,
/*uid=*/ 2L, currentUserId,
ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 15L, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 15L,
25L); /*foregroundServiceUsageTimeInMs=*/ 15L, /*backgroundUsageTimeInMs=*/ 25L);
entryMap.put(entry.getKey(), entry); entryMap.put(entry.getKey(), entry);
entryMap.put(fakeEntry.getKey(), fakeEntry); entryMap.put(fakeEntry.getKey(), fakeEntry);
batteryHistoryMap.put(batteryHistoryKeys[2], entryMap); batteryHistoryMap.put(batteryHistoryKeys[2], entryMap);
// Adds the index = 3 data. // Adds the index = 3 data.
entryMap = new HashMap<>(); entryMap = new HashMap<>();
entry = createBatteryHistEntry( entry = createBatteryHistEntry(
"package2", "label2", /*consumePower=*/ 40.0, /*uid=*/ 2L, currentUserId, "package2", "label2", /*consumePower=*/ 40.0,
/*foregroundUsageConsumePower=*/ 8, /*foregroundServiceUsageConsumePower=*/ 8,
/*backgroundUsageConsumePower=*/ 8, /*cachedUsageConsumePower=*/ 8,
/*uid=*/ 2L, currentUserId,
ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 25L, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 25L,
/*backgroundUsageTimeInMs=*/ 35L); /*foregroundServiceUsageTimeInMs=*/ 25L, /*backgroundUsageTimeInMs=*/ 35L);
entryMap.put(entry.getKey(), entry); entryMap.put(entry.getKey(), entry);
entry = createBatteryHistEntry( entry = createBatteryHistEntry(
"package2", "label2", /*consumePower=*/ 10.0, /*uid=*/ 3L, currentUserId, "package2", "label2", /*consumePower=*/ 10.0,
/*foregroundUsageConsumePower=*/ 4, /*foregroundServiceUsageConsumePower=*/ 2,
/*backgroundUsageConsumePower=*/ 2, /*cachedUsageConsumePower=*/ 2,
/*uid=*/ 3L, currentUserId,
ConvertUtils.CONSUMER_TYPE_SYSTEM_BATTERY, /*foregroundUsageTimeInMs=*/ 40L, ConvertUtils.CONSUMER_TYPE_SYSTEM_BATTERY, /*foregroundUsageTimeInMs=*/ 40L,
/*backgroundUsageTimeInMs=*/ 50L); /*foregroundServiceUsageTimeInMs=*/ 40L, /*backgroundUsageTimeInMs=*/ 50L);
entryMap.put(entry.getKey(), entry); entryMap.put(entry.getKey(), entry);
entry = createBatteryHistEntry( entry = createBatteryHistEntry(
"package3", "label3", /*consumePower=*/ 15.0, /*uid=*/ 4L, currentUserId, "package3", "label3", /*consumePower=*/ 15.0,
/*foregroundUsageConsumePower=*/ 6, /*foregroundServiceUsageConsumePower=*/ 3,
/*backgroundUsageConsumePower=*/ 3, /*cachedUsageConsumePower=*/ 3,
/*uid=*/ 4L, currentUserId,
ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 5L, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 5L,
/*backgroundUsageTimeInMs=*/ 5L); /*foregroundServiceUsageTimeInMs=*/ 5L, /*backgroundUsageTimeInMs=*/ 5L);
entryMap.put(entry.getKey(), entry); entryMap.put(entry.getKey(), entry);
entryMap.put(fakeEntry.getKey(), fakeEntry); entryMap.put(fakeEntry.getKey(), fakeEntry);
batteryHistoryMap.put(batteryHistoryKeys[3], entryMap); batteryHistoryMap.put(batteryHistoryKeys[3], entryMap);
// Adds the index = 4 data. // Adds the index = 4 data.
entryMap = new HashMap<>(); entryMap = new HashMap<>();
entry = createBatteryHistEntry( entry = createBatteryHistEntry(
"package2", "label2", /*consumePower=*/ 40.0, /*uid=*/ 2L, currentUserId, "package2", "label2", /*consumePower=*/ 40.0,
/*foregroundUsageConsumePower=*/ 14, /*foregroundServiceUsageConsumePower=*/ 9,
/*backgroundUsageConsumePower=*/ 9, /*cachedUsageConsumePower=*/ 8,
/*uid=*/ 2L, currentUserId,
ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 30L, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 30L,
/*backgroundUsageTimeInMs=*/ 40L); /*foregroundServiceUsageTimeInMs=*/ 30L, /*backgroundUsageTimeInMs=*/ 40L);
entryMap.put(entry.getKey(), entry); entryMap.put(entry.getKey(), entry);
entry = createBatteryHistEntry( entry = createBatteryHistEntry(
"package2", "label2", /*consumePower=*/ 20.0, /*uid=*/ 3L, currentUserId, "package2", "label2", /*consumePower=*/ 20.0,
/*foregroundUsageConsumePower=*/ 5, /*foregroundServiceUsageConsumePower=*/ 5,
/*backgroundUsageConsumePower=*/ 5, /*cachedUsageConsumePower=*/ 5,
/*uid=*/ 3L, currentUserId,
ConvertUtils.CONSUMER_TYPE_SYSTEM_BATTERY, /*foregroundUsageTimeInMs=*/ 50L, ConvertUtils.CONSUMER_TYPE_SYSTEM_BATTERY, /*foregroundUsageTimeInMs=*/ 50L,
/*backgroundUsageTimeInMs=*/ 60L); /*foregroundServiceUsageTimeInMs=*/ 50L, /*backgroundUsageTimeInMs=*/ 60L);
entryMap.put(entry.getKey(), entry); entryMap.put(entry.getKey(), entry);
entry = createBatteryHistEntry( entry = createBatteryHistEntry(
"package3", "label3", /*consumePower=*/ 40.0, /*uid=*/ 4L, currentUserId, "package3", "label3", /*consumePower=*/ 40.0,
/*foregroundUsageConsumePower=*/ 8, /*foregroundServiceUsageConsumePower=*/ 8,
/*backgroundUsageConsumePower=*/ 8, /*cachedUsageConsumePower=*/ 8,
/*uid=*/ 4L, currentUserId,
ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 5L, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 5L,
/*backgroundUsageTimeInMs=*/ 5L); /*foregroundServiceUsageTimeInMs=*/ 5L, /*backgroundUsageTimeInMs=*/ 5L);
entryMap.put(entry.getKey(), entry); entryMap.put(entry.getKey(), entry);
entryMap.put(fakeEntry.getKey(), fakeEntry); entryMap.put(fakeEntry.getKey(), fakeEntry);
batteryHistoryMap.put(batteryHistoryKeys[4], entryMap); batteryHistoryMap.put(batteryHistoryKeys[4], entryMap);
@@ -619,33 +646,54 @@ public class DataProcessorTest {
assertBatteryDiffEntry( assertBatteryDiffEntry(
resultDiffData.getAppDiffEntryList().get(0), currentUserId, /*uid=*/ 2L, resultDiffData.getAppDiffEntryList().get(0), currentUserId, /*uid=*/ 2L,
ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*consumePercentage=*/ 40.0, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*consumePercentage=*/ 40.0,
/*foregroundUsageTimeInMs=*/ 30, /*backgroundUsageTimeInMs=*/ 40); /*foregroundUsageConsumePower=*/ 14, /*foregroundServiceUsageConsumePower=*/ 9,
/*backgroundUsageConsumePower=*/ 9, /*cachedUsageConsumePower=*/ 8,
/*foregroundUsageTimeInMs=*/ 30, /*foregroundServiceUsageTimeInMs=*/ 30,
/*backgroundUsageTimeInMs=*/ 40);
assertBatteryDiffEntry( assertBatteryDiffEntry(
resultDiffData.getAppDiffEntryList().get(1), currentUserId, /*uid=*/ 4L, resultDiffData.getAppDiffEntryList().get(1), currentUserId, /*uid=*/ 4L,
ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*consumePercentage=*/ 40.0, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*consumePercentage=*/ 40.0,
/*foregroundUsageTimeInMs=*/ 5, /*backgroundUsageTimeInMs=*/ 5); /*foregroundUsageConsumePower=*/ 8, /*foregroundServiceUsageConsumePower=*/ 8,
/*backgroundUsageConsumePower=*/ 8, /*cachedUsageConsumePower=*/ 8,
/*foregroundUsageTimeInMs=*/ 5, /*foregroundServiceUsageTimeInMs=*/ 5,
/*backgroundUsageTimeInMs=*/ 5);
assertBatteryDiffEntry( assertBatteryDiffEntry(
resultDiffData.getSystemDiffEntryList().get(0), currentUserId, /*uid=*/ 3L, resultDiffData.getSystemDiffEntryList().get(0), currentUserId, /*uid=*/ 3L,
ConvertUtils.CONSUMER_TYPE_SYSTEM_BATTERY, /*consumePercentage=*/ 20.0, ConvertUtils.CONSUMER_TYPE_SYSTEM_BATTERY, /*consumePercentage=*/ 20.0,
/*foregroundUsageTimeInMs=*/ 50, /*backgroundUsageTimeInMs=*/ 60); /*foregroundUsageConsumePower=*/ 5, /*foregroundServiceUsageConsumePower=*/ 5,
/*backgroundUsageConsumePower=*/ 5, /*cachedUsageConsumePower=*/ 5,
/*foregroundUsageTimeInMs=*/ 50, /*foregroundServiceUsageTimeInMs=*/ 50,
/*backgroundUsageTimeInMs=*/ 60);
resultDiffData = resultMap.get(0).get(DataProcessor.SELECTED_INDEX_ALL); resultDiffData = resultMap.get(0).get(DataProcessor.SELECTED_INDEX_ALL);
assertBatteryDiffEntry( assertBatteryDiffEntry(
resultDiffData.getAppDiffEntryList().get(0), currentUserId, /*uid=*/ 2L, resultDiffData.getAppDiffEntryList().get(0), currentUserId, /*uid=*/ 2L,
ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*consumePercentage=*/ 100.0, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*consumePercentage=*/ 100.0,
/*foregroundUsageTimeInMs=*/ 15, /*backgroundUsageTimeInMs=*/ 25); /*foregroundUsageConsumePower=*/ 5, /*foregroundServiceUsageConsumePower=*/ 5,
/*backgroundUsageConsumePower=*/ 5, /*cachedUsageConsumePower=*/ 5,
/*foregroundUsageTimeInMs=*/ 15, /*foregroundServiceUsageTimeInMs=*/ 15,
/*backgroundUsageTimeInMs=*/ 25);
resultDiffData = resultMap.get(1).get(DataProcessor.SELECTED_INDEX_ALL); resultDiffData = resultMap.get(1).get(DataProcessor.SELECTED_INDEX_ALL);
assertBatteryDiffEntry( assertBatteryDiffEntry(
resultDiffData.getAppDiffEntryList().get(0), currentUserId, /*uid=*/ 4L, resultDiffData.getAppDiffEntryList().get(0), currentUserId, /*uid=*/ 4L,
ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*consumePercentage=*/ 50.0, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*consumePercentage=*/ 50.0,
/*foregroundUsageTimeInMs=*/ 5, /*backgroundUsageTimeInMs=*/ 5); /*foregroundUsageConsumePower=*/ 8, /*foregroundServiceUsageConsumePower=*/ 8,
/*backgroundUsageConsumePower=*/ 8, /*cachedUsageConsumePower=*/ 8,
/*foregroundUsageTimeInMs=*/ 5, /*foregroundServiceUsageTimeInMs=*/ 5,
/*backgroundUsageTimeInMs=*/ 5);
assertBatteryDiffEntry( assertBatteryDiffEntry(
resultDiffData.getAppDiffEntryList().get(1), currentUserId, /*uid=*/ 2L, resultDiffData.getAppDiffEntryList().get(1), currentUserId, /*uid=*/ 2L,
ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*consumePercentage=*/ 25.0, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*consumePercentage=*/ 25.0,
/*foregroundUsageTimeInMs=*/ 15, /*backgroundUsageTimeInMs=*/ 15); /*foregroundUsageConsumePower=*/ 9, /*foregroundServiceUsageConsumePower=*/ 4,
/*backgroundUsageConsumePower=*/ 4, /*cachedUsageConsumePower=*/ 3,
/*foregroundUsageTimeInMs=*/ 15, /*foregroundServiceUsageTimeInMs=*/ 15,
/*backgroundUsageTimeInMs=*/ 15);
assertBatteryDiffEntry( assertBatteryDiffEntry(
resultDiffData.getSystemDiffEntryList().get(0), currentUserId, /*uid=*/ 3L, resultDiffData.getSystemDiffEntryList().get(0), currentUserId, /*uid=*/ 3L,
ConvertUtils.CONSUMER_TYPE_SYSTEM_BATTERY, /*consumePercentage=*/ 25.0, ConvertUtils.CONSUMER_TYPE_SYSTEM_BATTERY, /*consumePercentage=*/ 25.0,
/*foregroundUsageTimeInMs=*/ 50, /*backgroundUsageTimeInMs=*/ 60); /*foregroundUsageConsumePower=*/ 5, /*foregroundServiceUsageConsumePower=*/ 5,
/*backgroundUsageConsumePower=*/ 5, /*cachedUsageConsumePower=*/ 5,
/*foregroundUsageTimeInMs=*/ 50, /*foregroundServiceUsageTimeInMs=*/ 50,
/*backgroundUsageTimeInMs=*/ 60);
verify(mMetricsFeatureProvider) verify(mMetricsFeatureProvider)
.action(mContext.getApplicationContext(), .action(mContext.getApplicationContext(),
SettingsEnums.ACTION_BATTERY_USAGE_SHOWN_APP_COUNT, SettingsEnums.ACTION_BATTERY_USAGE_SHOWN_APP_COUNT,
@@ -668,55 +716,82 @@ public class DataProcessorTest {
// Adds the index = 0 data. // Adds the index = 0 data.
Map<String, BatteryHistEntry> entryMap = new HashMap<>(); Map<String, BatteryHistEntry> entryMap = new HashMap<>();
BatteryHistEntry entry = createBatteryHistEntry( BatteryHistEntry entry = createBatteryHistEntry(
"package1", "label1", /*consumePower=*/ 5.0, /*uid=*/ 1L, currentUserId, "package1", "label1", /*consumePower=*/ 5.0,
/*foregroundUsageConsumePower=*/ 5, /*foregroundServiceUsageConsumePower=*/ 0,
/*backgroundUsageConsumePower=*/ 0, /*cachedUsageConsumePower=*/ 0,
/*uid=*/ 1L, currentUserId,
ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 10L, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 10L,
/*backgroundUsageTimeInMs=*/ 20L); /*foregroundServiceUsageTimeInMs=*/ 10L, /*backgroundUsageTimeInMs=*/ 20L);
entryMap.put(entry.getKey(), entry); entryMap.put(entry.getKey(), entry);
entry = createBatteryHistEntry( entry = createBatteryHistEntry(
"package1", "label1", /*consumePower=*/ 10.0, /*uid=*/ 2L, currentUserId + 1, "package1", "label1", /*consumePower=*/ 10.0,
/*foregroundUsageConsumePower=*/ 7, /*foregroundServiceUsageConsumePower=*/ 1,
/*backgroundUsageConsumePower=*/ 1, /*cachedUsageConsumePower=*/ 1,
/*uid=*/ 2L, currentUserId + 1,
ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 10L, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 10L,
/*backgroundUsageTimeInMs=*/ 20L); /*foregroundServiceUsageTimeInMs=*/ 10L, /*backgroundUsageTimeInMs=*/ 20L);
entryMap.put(entry.getKey(), entry); entryMap.put(entry.getKey(), entry);
entry = createBatteryHistEntry( entry = createBatteryHistEntry(
"package2", "label2", /*consumePower=*/ 5.0, /*uid=*/ 3L, currentUserId + 2, "package2", "label2", /*consumePower=*/ 5.0,
/*foregroundUsageConsumePower=*/ 5, /*foregroundServiceUsageConsumePower=*/ 0,
/*backgroundUsageConsumePower=*/ 0, /*cachedUsageConsumePower=*/ 0,
/*uid=*/ 3L, currentUserId + 2,
ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 20L, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 20L,
/*backgroundUsageTimeInMs=*/ 30L); /*foregroundServiceUsageTimeInMs=*/ 20L, /*backgroundUsageTimeInMs=*/ 30L);
entryMap.put(entry.getKey(), entry); entryMap.put(entry.getKey(), entry);
batteryHistoryMap.put(batteryHistoryKeys[0], entryMap); batteryHistoryMap.put(batteryHistoryKeys[0], entryMap);
// Adds the index = 1 data. // Adds the index = 1 data.
entryMap = new HashMap<>(); entryMap = new HashMap<>();
entry = createBatteryHistEntry( entry = createBatteryHistEntry(
"package1", "label1", /*consumePower=*/ 15.0, /*uid=*/ 1L, currentUserId, "package1", "label1", /*consumePower=*/ 15.0,
/*foregroundUsageConsumePower=*/ 9, /*foregroundServiceUsageConsumePower=*/ 2,
/*backgroundUsageConsumePower=*/ 2, /*cachedUsageConsumePower=*/ 2,
/*uid=*/ 1L, currentUserId,
ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 20L, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 20L,
/*backgroundUsageTimeInMs=*/ 30L); /*foregroundServiceUsageTimeInMs=*/ 20L, /*backgroundUsageTimeInMs=*/ 30L);
entryMap.put(entry.getKey(), entry); entryMap.put(entry.getKey(), entry);
entry = createBatteryHistEntry( entry = createBatteryHistEntry(
"package1", "label1", /*consumePower=*/ 30.0, /*uid=*/ 2L, currentUserId + 1, "package1", "label1", /*consumePower=*/ 30.0,
/*foregroundUsageConsumePower=*/ 20, /*foregroundServiceUsageConsumePower=*/ 6,
/*backgroundUsageConsumePower=*/ 2, /*cachedUsageConsumePower=*/ 2,
/*uid=*/ 2L, currentUserId + 1,
ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 10L, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 10L,
/*backgroundUsageTimeInMs=*/ 20L); /*foregroundServiceUsageTimeInMs=*/ 10L, /*backgroundUsageTimeInMs=*/ 20L);
entryMap.put(entry.getKey(), entry); entryMap.put(entry.getKey(), entry);
entry = createBatteryHistEntry( entry = createBatteryHistEntry(
"package2", "label2", /*consumePower=*/ 15.0, /*uid=*/ 3L, currentUserId + 2, "package2", "label2", /*consumePower=*/ 15.0,
/*foregroundUsageConsumePower=*/ 10, /*foregroundServiceUsageConsumePower=*/ 5,
/*backgroundUsageConsumePower=*/ 0, /*cachedUsageConsumePower=*/ 0,
/*uid=*/ 3L, currentUserId + 2,
ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 30L, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 30L,
/*backgroundUsageTimeInMs=*/ 30L); /*foregroundServiceUsageTimeInMs=*/ 30L, /*backgroundUsageTimeInMs=*/ 30L);
entryMap.put(entry.getKey(), entry); entryMap.put(entry.getKey(), entry);
batteryHistoryMap.put(batteryHistoryKeys[1], entryMap); batteryHistoryMap.put(batteryHistoryKeys[1], entryMap);
// Adds the index = 2 data. // Adds the index = 2 data.
entryMap = new HashMap<>(); entryMap = new HashMap<>();
entry = createBatteryHistEntry( entry = createBatteryHistEntry(
"package1", "label1", /*consumePower=*/ 25.0, /*uid=*/ 1L, currentUserId, "package1", "label1", /*consumePower=*/ 25.0,
/*foregroundUsageConsumePower=*/ 10, /*foregroundServiceUsageConsumePower=*/ 5,
/*backgroundUsageConsumePower=*/ 5, /*cachedUsageConsumePower=*/ 5,
/*uid=*/ 1L, currentUserId,
ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 20L, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 20L,
/*backgroundUsageTimeInMs=*/ 30L); /*foregroundServiceUsageTimeInMs=*/ 25L, /*backgroundUsageTimeInMs=*/ 30L);
entryMap.put(entry.getKey(), entry); entryMap.put(entry.getKey(), entry);
entry = createBatteryHistEntry( entry = createBatteryHistEntry(
"package1", "label1", /*consumePower=*/ 50.0, /*uid=*/ 2L, currentUserId + 1, "package1", "label1", /*consumePower=*/ 50.0,
/*foregroundUsageConsumePower=*/ 20, /*foregroundServiceUsageConsumePower=*/ 10,
/*backgroundUsageConsumePower=*/ 10, /*cachedUsageConsumePower=*/ 10,
/*uid=*/ 2L, currentUserId + 1,
ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 20L, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 20L,
/*backgroundUsageTimeInMs=*/ 20L); /*foregroundServiceUsageTimeInMs=*/ 25L, /*backgroundUsageTimeInMs=*/ 20L);
entryMap.put(entry.getKey(), entry); entryMap.put(entry.getKey(), entry);
entry = createBatteryHistEntry( entry = createBatteryHistEntry(
"package2", "label2", /*consumePower=*/ 25.0, /*uid=*/ 3L, currentUserId + 2, "package2", "label2", /*consumePower=*/ 25.0,
/*foregroundUsageConsumePower=*/ 10, /*foregroundServiceUsageConsumePower=*/ 10,
/*backgroundUsageConsumePower=*/ 5, /*cachedUsageConsumePower=*/ 0,
/*uid=*/ 3L, currentUserId + 2,
ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 30L, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 30L,
/*backgroundUsageTimeInMs=*/ 30L); /*foregroundServiceUsageTimeInMs=*/ 35L, /*backgroundUsageTimeInMs=*/ 30L);
entryMap.put(entry.getKey(), entry); entryMap.put(entry.getKey(), entry);
batteryHistoryMap.put(batteryHistoryKeys[2], entryMap); batteryHistoryMap.put(batteryHistoryKeys[2], entryMap);
final List<BatteryLevelData.PeriodBatteryLevelData> hourlyBatteryLevelsPerDay = final List<BatteryLevelData.PeriodBatteryLevelData> hourlyBatteryLevelsPerDay =
@@ -737,11 +812,17 @@ public class DataProcessorTest {
assertBatteryDiffEntry( assertBatteryDiffEntry(
resultDiffData.getAppDiffEntryList().get(0), currentUserId, /*uid=*/ 1L, resultDiffData.getAppDiffEntryList().get(0), currentUserId, /*uid=*/ 1L,
ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*consumePercentage=*/ 25.0, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*consumePercentage=*/ 25.0,
/*foregroundUsageTimeInMs=*/ 10, /*backgroundUsageTimeInMs=*/ 10); /*foregroundUsageConsumePower=*/ 5, /*foregroundServiceUsageConsumePower=*/ 5,
/*backgroundUsageConsumePower=*/ 5, /*cachedUsageConsumePower=*/ 5,
/*foregroundUsageTimeInMs=*/ 10, /*foregroundServiceUsageTimeInMs=*/ 15,
/*backgroundUsageTimeInMs=*/ 10);
assertBatteryDiffEntry( assertBatteryDiffEntry(
resultDiffData.getSystemDiffEntryList().get(0), BatteryUtils.UID_OTHER_USERS, resultDiffData.getSystemDiffEntryList().get(0), BatteryUtils.UID_OTHER_USERS,
/*uid=*/ BatteryUtils.UID_OTHER_USERS, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*uid=*/ BatteryUtils.UID_OTHER_USERS, ConvertUtils.CONSUMER_TYPE_UID_BATTERY,
/*consumePercentage=*/ 75.0, /*foregroundUsageTimeInMs=*/ 0, /*consumePercentage=*/ 75.0,
/*foregroundUsageConsumePower=*/ 0, /*foregroundServiceUsageConsumePower=*/ 0,
/*backgroundUsageConsumePower=*/ 0, /*cachedUsageConsumePower=*/ 0,
/*foregroundUsageTimeInMs=*/ 0, /*foregroundServiceUsageTimeInMs=*/ 0,
/*backgroundUsageTimeInMs=*/ 0); /*backgroundUsageTimeInMs=*/ 0);
assertThat(resultMap.get(0).get(0)).isNotNull(); assertThat(resultMap.get(0).get(0)).isNotNull();
assertThat(resultMap.get(0).get(DataProcessor.SELECTED_INDEX_ALL)).isNotNull(); assertThat(resultMap.get(0).get(DataProcessor.SELECTED_INDEX_ALL)).isNotNull();
@@ -767,24 +848,34 @@ public class DataProcessorTest {
// Adds the index = 0 data. // Adds the index = 0 data.
Map<String, BatteryHistEntry> entryMap = new HashMap<>(); Map<String, BatteryHistEntry> entryMap = new HashMap<>();
BatteryHistEntry entry = createBatteryHistEntry( BatteryHistEntry entry = createBatteryHistEntry(
"package1", "label1", /*consumePower=*/ 0, /*uid=*/ 1L, currentUserId, "package1", "label1", /*consumePower=*/ 0,
/*foregroundUsageConsumePower=*/ 0, /*foregroundServiceUsageConsumePower=*/ 0,
/*backgroundUsageConsumePower=*/ 0, /*cachedUsageConsumePower=*/ 0,
/*uid=*/ 1L, currentUserId,
ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 0L, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 0L,
/*backgroundUsageTimeInMs=*/ 0L); /*foregroundServiceUsageTimeInMs=*/ 0L, /*backgroundUsageTimeInMs=*/ 0L);
entryMap.put(entry.getKey(), entry); entryMap.put(entry.getKey(), entry);
batteryHistoryMap.put(batteryHistoryKeys[0], entryMap); batteryHistoryMap.put(batteryHistoryKeys[0], entryMap);
// Adds the index = 1 data. // Adds the index = 1 data.
entryMap = new HashMap<>(); entryMap = new HashMap<>();
entry = createBatteryHistEntry( entry = createBatteryHistEntry(
"package1", "label1", /*consumePower=*/ 0, /*uid=*/ 1L, currentUserId, "package1", "label1", /*consumePower=*/ 0,
/*foregroundUsageConsumePower=*/ 0, /*foregroundServiceUsageConsumePower=*/ 0,
/*backgroundUsageConsumePower=*/ 0, /*cachedUsageConsumePower=*/ 0,
/*uid=*/ 1L, currentUserId,
ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 0L, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 0L,
/*backgroundUsageTimeInMs=*/ 0L); /*foregroundServiceUsageTimeInMs=*/ 0L, /*backgroundUsageTimeInMs=*/ 0L);
entryMap.put(entry.getKey(), entry); entryMap.put(entry.getKey(), entry);
batteryHistoryMap.put(batteryHistoryKeys[1], entryMap); batteryHistoryMap.put(batteryHistoryKeys[1], entryMap);
// Adds the index = 2 data. // Adds the index = 2 data.
entryMap = new HashMap<>(); entryMap = new HashMap<>();
entry = createBatteryHistEntry( entry = createBatteryHistEntry(
"package1", "label1", /*consumePower=*/ 500.0, /*uid=*/ 1L, currentUserId, "package1", "label1", /*consumePower=*/ 500.0,
/*foregroundUsageConsumePower=*/ 200, /*foregroundServiceUsageConsumePower=*/ 100,
/*backgroundUsageConsumePower=*/ 100, /*cachedUsageConsumePower=*/ 100,
/*uid=*/ 1L, currentUserId,
ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 3600000L, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 3600000L,
/*foregroundServiceUsageTimeInMs=*/ 1800000L,
/*backgroundUsageTimeInMs=*/ 7200000L); /*backgroundUsageTimeInMs=*/ 7200000L);
entryMap.put(entry.getKey(), entry); entryMap.put(entry.getKey(), entry);
batteryHistoryMap.put(batteryHistoryKeys[2], entryMap); batteryHistoryMap.put(batteryHistoryKeys[2], entryMap);
@@ -808,10 +899,20 @@ public class DataProcessorTest {
final BatteryDiffEntry resultEntry = resultDiffData.getAppDiffEntryList().get(0); final BatteryDiffEntry resultEntry = resultDiffData.getAppDiffEntryList().get(0);
assertThat(resultEntry.mForegroundUsageTimeInMs) assertThat(resultEntry.mForegroundUsageTimeInMs)
.isEqualTo(Math.round(entry.mForegroundUsageTimeInMs * ratio)); .isEqualTo(Math.round(entry.mForegroundUsageTimeInMs * ratio));
assertThat(resultEntry.mForegroundServiceUsageTimeInMs)
.isEqualTo(Math.round(entry.mForegroundServiceUsageTimeInMs * ratio));
assertThat(resultEntry.mBackgroundUsageTimeInMs) assertThat(resultEntry.mBackgroundUsageTimeInMs)
.isEqualTo(Math.round(entry.mBackgroundUsageTimeInMs * ratio)); .isEqualTo(Math.round(entry.mBackgroundUsageTimeInMs * ratio));
assertThat(resultEntry.mConsumePower) assertThat(resultEntry.mConsumePower)
.isEqualTo(entry.mConsumePower * ratio); .isEqualTo(entry.mConsumePower * ratio);
assertThat(resultEntry.mForegroundUsageConsumePower)
.isEqualTo(entry.mForegroundUsageConsumePower * ratio);
assertThat(resultEntry.mForegroundServiceUsageConsumePower)
.isEqualTo(entry.mForegroundServiceUsageConsumePower * ratio);
assertThat(resultEntry.mBackgroundUsageConsumePower)
.isEqualTo(entry.mBackgroundUsageConsumePower * ratio);
assertThat(resultEntry.mCachedUsageConsumePower)
.isEqualTo(entry.mCachedUsageConsumePower * ratio);
assertThat(resultMap.get(0).get(0)).isNotNull(); assertThat(resultMap.get(0).get(0)).isNotNull();
assertThat(resultMap.get(0).get(DataProcessor.SELECTED_INDEX_ALL)).isNotNull(); assertThat(resultMap.get(0).get(DataProcessor.SELECTED_INDEX_ALL)).isNotNull();
verify(mMetricsFeatureProvider) verify(mMetricsFeatureProvider)
@@ -836,40 +937,58 @@ public class DataProcessorTest {
// Adds the index = 0 data. // Adds the index = 0 data.
Map<String, BatteryHistEntry> entryMap = new HashMap<>(); Map<String, BatteryHistEntry> entryMap = new HashMap<>();
BatteryHistEntry entry = createBatteryHistEntry( BatteryHistEntry entry = createBatteryHistEntry(
"package1", "label1", /*consumePower=*/ 0, /*uid=*/ 1L, currentUserId, "package1", "label1", /*consumePower=*/ 0,
/*foregroundUsageConsumePower=*/ 0, /*foregroundServiceUsageConsumePower=*/ 0,
/*backgroundUsageConsumePower=*/ 0, /*cachedUsageConsumePower=*/ 0,
/*uid=*/ 1L, currentUserId,
ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 0L, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 0L,
/*backgroundUsageTimeInMs=*/ 0L); /*foregroundServiceUsageTimeInMs=*/ 0L, /*backgroundUsageTimeInMs=*/ 0L);
entryMap.put(entry.getKey(), entry); entryMap.put(entry.getKey(), entry);
entry = createBatteryHistEntry( entry = createBatteryHistEntry(
"package2", "label2", /*consumePower=*/ 0, /*uid=*/ 2L, currentUserId, "package2", "label2", /*consumePower=*/ 0,
/*foregroundUsageConsumePower=*/ 0, /*foregroundServiceUsageConsumePower=*/ 0,
/*backgroundUsageConsumePower=*/ 0, /*cachedUsageConsumePower=*/ 0,
/*uid=*/ 2L, currentUserId,
ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 0L, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 0L,
/*backgroundUsageTimeInMs=*/ 0L); /*foregroundServiceUsageTimeInMs=*/ 0L, /*backgroundUsageTimeInMs=*/ 0L);
entryMap.put(entry.getKey(), entry); entryMap.put(entry.getKey(), entry);
batteryHistoryMap.put(batteryHistoryKeys[0], entryMap); batteryHistoryMap.put(batteryHistoryKeys[0], entryMap);
// Adds the index = 1 data. // Adds the index = 1 data.
entryMap = new HashMap<>(); entryMap = new HashMap<>();
entry = createBatteryHistEntry( entry = createBatteryHistEntry(
"package1", "label1", /*consumePower=*/ 0, /*uid=*/ 1L, currentUserId, "package1", "label1", /*consumePower=*/ 0,
/*foregroundUsageConsumePower=*/ 0, /*foregroundServiceUsageConsumePower=*/ 0,
/*backgroundUsageConsumePower=*/ 0, /*cachedUsageConsumePower=*/ 0,
/*uid=*/ 1L, currentUserId,
ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 0L, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 0L,
/*backgroundUsageTimeInMs=*/ 0L); /*foregroundServiceUsageTimeInMs=*/ 0L, /*backgroundUsageTimeInMs=*/ 0L);
entryMap.put(entry.getKey(), entry); entryMap.put(entry.getKey(), entry);
entry = createBatteryHistEntry( entry = createBatteryHistEntry(
"package2", "label2", /*consumePower=*/ 0, /*uid=*/ 2L, currentUserId, "package2", "label2", /*consumePower=*/ 0,
/*foregroundUsageConsumePower=*/ 0, /*foregroundServiceUsageConsumePower=*/ 0,
/*backgroundUsageConsumePower=*/ 0, /*cachedUsageConsumePower=*/ 0,
/*uid=*/ 2L, currentUserId,
ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 0L, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 0L,
/*backgroundUsageTimeInMs=*/ 0L); /*foregroundServiceUsageTimeInMs=*/ 0L, /*backgroundUsageTimeInMs=*/ 0L);
entryMap.put(entry.getKey(), entry); entryMap.put(entry.getKey(), entry);
batteryHistoryMap.put(batteryHistoryKeys[1], entryMap); batteryHistoryMap.put(batteryHistoryKeys[1], entryMap);
// Adds the index = 2 data. // Adds the index = 2 data.
entryMap = new HashMap<>(); entryMap = new HashMap<>();
entry = createBatteryHistEntry( entry = createBatteryHistEntry(
"package1", "label1", /*consumePower=*/ 10.0, /*uid=*/ 1L, currentUserId, "package1", "label1", /*consumePower=*/ 10.0,
/*foregroundUsageConsumePower=*/ 5, /*foregroundServiceUsageConsumePower=*/ 5,
/*backgroundUsageConsumePower=*/ 0, /*cachedUsageConsumePower=*/ 0,
/*uid=*/ 1L, currentUserId,
ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 10L, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 10L,
/*backgroundUsageTimeInMs=*/ 20L); /*foregroundServiceUsageTimeInMs=*/ 15L, /*backgroundUsageTimeInMs=*/ 20L);
entryMap.put(entry.getKey(), entry); entryMap.put(entry.getKey(), entry);
entry = createBatteryHistEntry( entry = createBatteryHistEntry(
"package2", "label2", /*consumePower=*/ 10.0, /*uid=*/ 2L, currentUserId, "package2", "label2", /*consumePower=*/ 10.0,
/*foregroundUsageConsumePower=*/ 0, /*foregroundServiceUsageConsumePower=*/ 0,
/*backgroundUsageConsumePower=*/ 5, /*cachedUsageConsumePower=*/ 5,
/*uid=*/ 2L, currentUserId,
ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 10L, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 10L,
/*backgroundUsageTimeInMs=*/ 20L); /*foregroundServiceUsageTimeInMs=*/ 15L, /*backgroundUsageTimeInMs=*/ 20L);
entryMap.put(entry.getKey(), entry); entryMap.put(entry.getKey(), entry);
batteryHistoryMap.put(batteryHistoryKeys[2], entryMap); batteryHistoryMap.put(batteryHistoryKeys[2], entryMap);
final List<BatteryLevelData.PeriodBatteryLevelData> hourlyBatteryLevelsPerDay = final List<BatteryLevelData.PeriodBatteryLevelData> hourlyBatteryLevelsPerDay =
@@ -892,7 +1011,10 @@ public class DataProcessorTest {
assertBatteryDiffEntry( assertBatteryDiffEntry(
resultDiffData.getAppDiffEntryList().get(0), currentUserId, /*uid=*/ 2L, resultDiffData.getAppDiffEntryList().get(0), currentUserId, /*uid=*/ 2L,
ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*consumePercentage=*/ 50.0, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*consumePercentage=*/ 50.0,
/*foregroundUsageTimeInMs=*/ 10, /*backgroundUsageTimeInMs=*/ 20); /*foregroundUsageConsumePower=*/ 0, /*foregroundServiceUsageConsumePower=*/ 0,
/*backgroundUsageConsumePower=*/ 5, /*cachedUsageConsumePower=*/ 5,
/*foregroundUsageTimeInMs=*/ 10, /*foregroundServiceUsageTimeInMs=*/ 15,
/*backgroundUsageTimeInMs=*/ 20);
verify(mMetricsFeatureProvider) verify(mMetricsFeatureProvider)
.action(mContext.getApplicationContext(), .action(mContext.getApplicationContext(),
SettingsEnums.ACTION_BATTERY_USAGE_SHOWN_APP_COUNT, SettingsEnums.ACTION_BATTERY_USAGE_SHOWN_APP_COUNT,
@@ -915,40 +1037,58 @@ public class DataProcessorTest {
// Adds the index = 0 data. // Adds the index = 0 data.
Map<String, BatteryHistEntry> entryMap = new HashMap<>(); Map<String, BatteryHistEntry> entryMap = new HashMap<>();
BatteryHistEntry entry = createBatteryHistEntry( BatteryHistEntry entry = createBatteryHistEntry(
"package1", "label1", /*consumePower=*/ 0, /*uid=*/ 1L, currentUserId, "package1", "label1", /*consumePower=*/ 0,
/*foregroundUsageConsumePower=*/ 0, /*foregroundServiceUsageConsumePower=*/ 0,
/*backgroundUsageConsumePower=*/ 0, /*cachedUsageConsumePower=*/ 0,
/*uid=*/ 1L, currentUserId,
ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 0L, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 0L,
/*backgroundUsageTimeInMs=*/ 0L); /*foregroundServiceUsageTimeInMs=*/ 0L, /*backgroundUsageTimeInMs=*/ 0L);
entryMap.put(entry.getKey(), entry); entryMap.put(entry.getKey(), entry);
entry = createBatteryHistEntry( entry = createBatteryHistEntry(
"package2", "label2", /*consumePower=*/ 0, /*uid=*/ 2L, currentUserId, "package2", "label2", /*consumePower=*/ 0,
/*foregroundUsageConsumePower=*/ 0, /*foregroundServiceUsageConsumePower=*/ 0,
/*backgroundUsageConsumePower=*/ 0, /*cachedUsageConsumePower=*/ 0,
/*uid=*/ 2L, currentUserId,
ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 0L, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 0L,
/*backgroundUsageTimeInMs=*/ 0L); /*foregroundServiceUsageTimeInMs=*/ 0L, /*backgroundUsageTimeInMs=*/ 0L);
entryMap.put(entry.getKey(), entry); entryMap.put(entry.getKey(), entry);
batteryHistoryMap.put(batteryHistoryKeys[0], entryMap); batteryHistoryMap.put(batteryHistoryKeys[0], entryMap);
// Adds the index = 1 data. // Adds the index = 1 data.
entryMap = new HashMap<>(); entryMap = new HashMap<>();
entry = createBatteryHistEntry( entry = createBatteryHistEntry(
"package1", "label1", /*consumePower=*/ 0, /*uid=*/ 1L, currentUserId, "package1", "label1", /*consumePower=*/ 0,
/*foregroundUsageConsumePower=*/ 0, /*foregroundServiceUsageConsumePower=*/ 0,
/*backgroundUsageConsumePower=*/ 0, /*cachedUsageConsumePower=*/ 0,
/*uid=*/ 1L, currentUserId,
ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 0L, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 0L,
/*backgroundUsageTimeInMs=*/ 0L); /*foregroundServiceUsageTimeInMs=*/ 0L, /*backgroundUsageTimeInMs=*/ 0L);
entryMap.put(entry.getKey(), entry); entryMap.put(entry.getKey(), entry);
entry = createBatteryHistEntry( entry = createBatteryHistEntry(
"package2", "label2", /*consumePower=*/ 0, /*uid=*/ 2L, currentUserId, "package2", "label2", /*consumePower=*/ 0,
/*foregroundUsageConsumePower=*/ 0, /*foregroundServiceUsageConsumePower=*/ 0,
/*backgroundUsageConsumePower=*/ 0, /*cachedUsageConsumePower=*/ 0,
/*uid=*/ 2L, currentUserId,
ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 0L, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 0L,
/*backgroundUsageTimeInMs=*/ 0L); /*foregroundServiceUsageTimeInMs=*/ 0L, /*backgroundUsageTimeInMs=*/ 0L);
entryMap.put(entry.getKey(), entry); entryMap.put(entry.getKey(), entry);
batteryHistoryMap.put(batteryHistoryKeys[1], entryMap); batteryHistoryMap.put(batteryHistoryKeys[1], entryMap);
// Adds the index = 2 data. // Adds the index = 2 data.
entryMap = new HashMap<>(); entryMap = new HashMap<>();
entry = createBatteryHistEntry( entry = createBatteryHistEntry(
"package1", "label1", /*consumePower=*/ 10.0, /*uid=*/ 1L, currentUserId, "package1", "label1", /*consumePower=*/ 10.0,
/*foregroundUsageConsumePower=*/ 5, /*foregroundServiceUsageConsumePower=*/ 5,
/*backgroundUsageConsumePower=*/ 0, /*cachedUsageConsumePower=*/ 0,
/*uid=*/ 1L, currentUserId,
ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 10L, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 10L,
/*backgroundUsageTimeInMs=*/ 20L); /*foregroundServiceUsageTimeInMs=*/ 15L, /*backgroundUsageTimeInMs=*/ 20L);
entryMap.put(entry.getKey(), entry); entryMap.put(entry.getKey(), entry);
entry = createBatteryHistEntry( entry = createBatteryHistEntry(
"package2", "label2", /*consumePower=*/ 10.0, /*uid=*/ 2L, currentUserId, "package2", "label2", /*consumePower=*/ 10.0,
/*foregroundUsageConsumePower=*/ 0, /*foregroundServiceUsageConsumePower=*/ 0,
/*backgroundUsageConsumePower=*/ 5, /*cachedUsageConsumePower=*/ 5,
/*uid=*/ 2L, currentUserId,
ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 10L, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*foregroundUsageTimeInMs=*/ 10L,
/*backgroundUsageTimeInMs=*/ 20L); /*foregroundServiceUsageTimeInMs=*/ 15L, /*backgroundUsageTimeInMs=*/ 20L);
entryMap.put(entry.getKey(), entry); entryMap.put(entry.getKey(), entry);
batteryHistoryMap.put(batteryHistoryKeys[2], entryMap); batteryHistoryMap.put(batteryHistoryKeys[2], entryMap);
final List<BatteryLevelData.PeriodBatteryLevelData> hourlyBatteryLevelsPerDay = final List<BatteryLevelData.PeriodBatteryLevelData> hourlyBatteryLevelsPerDay =
@@ -996,22 +1136,42 @@ public class DataProcessorTest {
batteryEntryList.add(mMockBatteryEntry3); batteryEntryList.add(mMockBatteryEntry3);
batteryEntryList.add(mMockBatteryEntry4); batteryEntryList.add(mMockBatteryEntry4);
doReturn(0.0).when(mMockBatteryEntry1).getConsumedPower(); doReturn(0.0).when(mMockBatteryEntry1).getConsumedPower();
doReturn(0.0).when(mMockBatteryEntry1).getConsumedPowerInForeground();
doReturn(0.0).when(mMockBatteryEntry1).getConsumedPowerInForegroundService();
doReturn(0.0).when(mMockBatteryEntry1).getConsumedPowerInBackground();
doReturn(0.0).when(mMockBatteryEntry1).getConsumedPowerInCached();
doReturn(30L).when(mMockBatteryEntry1).getTimeInForegroundMs(); doReturn(30L).when(mMockBatteryEntry1).getTimeInForegroundMs();
doReturn(20L).when(mMockBatteryEntry1).getTimeInForegroundServiceMs();
doReturn(40L).when(mMockBatteryEntry1).getTimeInBackgroundMs(); doReturn(40L).when(mMockBatteryEntry1).getTimeInBackgroundMs();
doReturn(1).when(mMockBatteryEntry1).getUid(); doReturn(1).when(mMockBatteryEntry1).getUid();
doReturn(ConvertUtils.CONSUMER_TYPE_UID_BATTERY).when(mMockBatteryEntry1).getConsumerType(); doReturn(ConvertUtils.CONSUMER_TYPE_UID_BATTERY).when(mMockBatteryEntry1).getConsumerType();
doReturn(0.5).when(mMockBatteryEntry2).getConsumedPower(); doReturn(0.5).when(mMockBatteryEntry2).getConsumedPower();
doReturn(0.5).when(mMockBatteryEntry2).getConsumedPowerInForeground();
doReturn(0.0).when(mMockBatteryEntry2).getConsumedPowerInForegroundService();
doReturn(0.0).when(mMockBatteryEntry2).getConsumedPowerInBackground();
doReturn(0.0).when(mMockBatteryEntry2).getConsumedPowerInCached();
doReturn(20L).when(mMockBatteryEntry2).getTimeInForegroundMs(); doReturn(20L).when(mMockBatteryEntry2).getTimeInForegroundMs();
doReturn(30L).when(mMockBatteryEntry2).getTimeInForegroundServiceMs();
doReturn(20L).when(mMockBatteryEntry2).getTimeInBackgroundMs(); doReturn(20L).when(mMockBatteryEntry2).getTimeInBackgroundMs();
doReturn(2).when(mMockBatteryEntry2).getUid(); doReturn(2).when(mMockBatteryEntry2).getUid();
doReturn(ConvertUtils.CONSUMER_TYPE_UID_BATTERY).when(mMockBatteryEntry2).getConsumerType(); doReturn(ConvertUtils.CONSUMER_TYPE_UID_BATTERY).when(mMockBatteryEntry2).getConsumerType();
doReturn(0.0).when(mMockBatteryEntry3).getConsumedPower(); doReturn(0.0).when(mMockBatteryEntry3).getConsumedPower();
doReturn(0.0).when(mMockBatteryEntry3).getConsumedPowerInForeground();
doReturn(0.0).when(mMockBatteryEntry3).getConsumedPowerInForegroundService();
doReturn(0.0).when(mMockBatteryEntry3).getConsumedPowerInBackground();
doReturn(0.0).when(mMockBatteryEntry3).getConsumedPowerInCached();
doReturn(0L).when(mMockBatteryEntry3).getTimeInForegroundMs(); doReturn(0L).when(mMockBatteryEntry3).getTimeInForegroundMs();
doReturn(0L).when(mMockBatteryEntry3).getTimeInForegroundServiceMs();
doReturn(0L).when(mMockBatteryEntry3).getTimeInBackgroundMs(); doReturn(0L).when(mMockBatteryEntry3).getTimeInBackgroundMs();
doReturn(3).when(mMockBatteryEntry3).getUid(); doReturn(3).when(mMockBatteryEntry3).getUid();
doReturn(ConvertUtils.CONSUMER_TYPE_UID_BATTERY).when(mMockBatteryEntry3).getConsumerType(); doReturn(ConvertUtils.CONSUMER_TYPE_UID_BATTERY).when(mMockBatteryEntry3).getConsumerType();
doReturn(1.5).when(mMockBatteryEntry4).getConsumedPower(); doReturn(1.5).when(mMockBatteryEntry4).getConsumedPower();
doReturn(0.9).when(mMockBatteryEntry4).getConsumedPowerInForeground();
doReturn(0.2).when(mMockBatteryEntry4).getConsumedPowerInForegroundService();
doReturn(0.3).when(mMockBatteryEntry4).getConsumedPowerInBackground();
doReturn(0.1).when(mMockBatteryEntry4).getConsumedPowerInCached();
doReturn(10L).when(mMockBatteryEntry4).getTimeInForegroundMs(); doReturn(10L).when(mMockBatteryEntry4).getTimeInForegroundMs();
doReturn(15L).when(mMockBatteryEntry4).getTimeInForegroundServiceMs();
doReturn(10L).when(mMockBatteryEntry4).getTimeInBackgroundMs(); doReturn(10L).when(mMockBatteryEntry4).getTimeInBackgroundMs();
doReturn(4).when(mMockBatteryEntry4).getUid(); doReturn(4).when(mMockBatteryEntry4).getUid();
doReturn(ConvertUtils.CONSUMER_TYPE_SYSTEM_BATTERY) doReturn(ConvertUtils.CONSUMER_TYPE_SYSTEM_BATTERY)
@@ -1025,15 +1185,24 @@ public class DataProcessorTest {
assertBatteryDiffEntry( assertBatteryDiffEntry(
batteryDiffData.getAppDiffEntryList().get(0), 0, /*uid=*/ 2L, batteryDiffData.getAppDiffEntryList().get(0), 0, /*uid=*/ 2L,
ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*consumePercentage=*/ 25.0, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*consumePercentage=*/ 25.0,
/*foregroundUsageTimeInMs=*/ 20, /*backgroundUsageTimeInMs=*/ 20); /*foregroundUsageConsumePower=*/ 0.5, /*foregroundServiceUsageConsumePower=*/ 0,
/*backgroundUsageConsumePower=*/ 0, /*cachedUsageConsumePower=*/ 0,
/*foregroundUsageTimeInMs=*/ 20, /*foregroundServiceUsageTimeInMs=*/ 30,
/*backgroundUsageTimeInMs=*/ 20);
assertBatteryDiffEntry( assertBatteryDiffEntry(
batteryDiffData.getAppDiffEntryList().get(1), 0, /*uid=*/ 1L, batteryDiffData.getAppDiffEntryList().get(1), 0, /*uid=*/ 1L,
ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*consumePercentage=*/ 0.0, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /*consumePercentage=*/ 0.0,
/*foregroundUsageTimeInMs=*/ 30, /*backgroundUsageTimeInMs=*/ 40); /*foregroundUsageConsumePower=*/ 0, /*foregroundServiceUsageConsumePower=*/ 0,
/*backgroundUsageConsumePower=*/ 0, /*cachedUsageConsumePower=*/ 0,
/*foregroundUsageTimeInMs=*/ 30, /*foregroundServiceUsageTimeInMs=*/ 20,
/*backgroundUsageTimeInMs=*/ 40);
assertBatteryDiffEntry( assertBatteryDiffEntry(
batteryDiffData.getSystemDiffEntryList().get(0), 0, /*uid=*/ 4L, batteryDiffData.getSystemDiffEntryList().get(0), 0, /*uid=*/ 4L,
ConvertUtils.CONSUMER_TYPE_SYSTEM_BATTERY, /*consumePercentage=*/ 75.0, ConvertUtils.CONSUMER_TYPE_SYSTEM_BATTERY, /*consumePercentage=*/ 75.0,
/*foregroundUsageTimeInMs=*/ 10, /*backgroundUsageTimeInMs=*/ 10); /*foregroundUsageConsumePower=*/ 0.9, /*foregroundServiceUsageConsumePower=*/ 0.2,
/*backgroundUsageConsumePower=*/ 0.3, /*cachedUsageConsumePower=*/ 0.1,
/*foregroundUsageTimeInMs=*/ 10, /*foregroundServiceUsageTimeInMs=*/ 15,
/*backgroundUsageTimeInMs=*/ 10);
} }
private static Map<Long, Map<String, BatteryHistEntry>> createHistoryMap( private static Map<Long, Map<String, BatteryHistEntry>> createHistoryMap(
@@ -1068,15 +1237,24 @@ public class DataProcessorTest {
private static BatteryHistEntry createBatteryHistEntry( private static BatteryHistEntry createBatteryHistEntry(
final String packageName, final String appLabel, final double consumePower, final String packageName, final String appLabel, final double consumePower,
final double foregroundUsageConsumePower,
final double foregroundServiceUsageConsumePower,
final double backgroundUsageConsumePower, final double cachedUsageConsumePower,
final long uid, final long userId, final int consumerType, final long uid, final long userId, final int consumerType,
final long foregroundUsageTimeInMs, final long backgroundUsageTimeInMs) { final long foregroundUsageTimeInMs, final long foregroundServiceUsageTimeInMs,
final long backgroundUsageTimeInMs) {
// Only insert required fields. // Only insert required fields.
final BatteryInformation batteryInformation = final BatteryInformation batteryInformation =
BatteryInformation BatteryInformation
.newBuilder() .newBuilder()
.setAppLabel(appLabel) .setAppLabel(appLabel)
.setConsumePower(consumePower) .setConsumePower(consumePower)
.setForegroundUsageConsumePower(foregroundUsageConsumePower)
.setForegroundServiceUsageConsumePower(foregroundServiceUsageConsumePower)
.setBackgroundUsageConsumePower(backgroundUsageConsumePower)
.setCachedUsageConsumePower(cachedUsageConsumePower)
.setForegroundUsageTimeInMs(foregroundUsageTimeInMs) .setForegroundUsageTimeInMs(foregroundUsageTimeInMs)
.setForegroundServiceUsageTimeInMs(foregroundServiceUsageTimeInMs)
.setBackgroundUsageTimeInMs(backgroundUsageTimeInMs) .setBackgroundUsageTimeInMs(backgroundUsageTimeInMs)
.build(); .build();
final ContentValues values = new ContentValues(); final ContentValues values = new ContentValues();
@@ -1152,12 +1330,23 @@ public class DataProcessorTest {
private static void assertBatteryDiffEntry( private static void assertBatteryDiffEntry(
final BatteryDiffEntry entry, final long userId, final long uid, final BatteryDiffEntry entry, final long userId, final long uid,
final int consumerType, final double consumePercentage, final int consumerType, final double consumePercentage,
final long foregroundUsageTimeInMs, final long backgroundUsageTimeInMs) { final double foregroundUsageConsumePower,
final double foregroundServiceUsageConsumePower,
final double backgroundUsageConsumePower, final double cachedUsageConsumePower,
final long foregroundUsageTimeInMs, final long foregroundServiceUsageTimeInMs,
final long backgroundUsageTimeInMs) {
assertThat(entry.mBatteryHistEntry.mUserId).isEqualTo(userId); assertThat(entry.mBatteryHistEntry.mUserId).isEqualTo(userId);
assertThat(entry.mBatteryHistEntry.mUid).isEqualTo(uid); assertThat(entry.mBatteryHistEntry.mUid).isEqualTo(uid);
assertThat(entry.mBatteryHistEntry.mConsumerType).isEqualTo(consumerType); assertThat(entry.mBatteryHistEntry.mConsumerType).isEqualTo(consumerType);
assertThat(entry.getPercentOfTotal()).isEqualTo(consumePercentage); assertThat(entry.getPercentOfTotal()).isEqualTo(consumePercentage);
assertThat(entry.mForegroundUsageConsumePower).isEqualTo(foregroundUsageConsumePower);
assertThat(entry.mForegroundServiceUsageConsumePower)
.isEqualTo(foregroundServiceUsageConsumePower);
assertThat(entry.mBackgroundUsageConsumePower).isEqualTo(backgroundUsageConsumePower);
assertThat(entry.mCachedUsageConsumePower).isEqualTo(cachedUsageConsumePower);
assertThat(entry.mForegroundUsageTimeInMs).isEqualTo(foregroundUsageTimeInMs); assertThat(entry.mForegroundUsageTimeInMs).isEqualTo(foregroundUsageTimeInMs);
assertThat(entry.mForegroundServiceUsageTimeInMs)
.isEqualTo(foregroundServiceUsageTimeInMs);
assertThat(entry.mBackgroundUsageTimeInMs).isEqualTo(backgroundUsageTimeInMs); assertThat(entry.mBackgroundUsageTimeInMs).isEqualTo(backgroundUsageTimeInMs);
} }
} }

5
tests/robotests/src/com/android/settings/fuelgauge/batteryusage/db/BatteryStateTest.java
View File

@@ -56,9 +56,14 @@ public final class BatteryStateTest {
.setAppLabel("Settings") .setAppLabel("Settings")
.setTotalPower(100) .setTotalPower(100)
.setConsumePower(3) .setConsumePower(3)
.setForegroundUsageConsumePower(0)
.setForegroundServiceUsageConsumePower(1)
.setBackgroundUsageConsumePower(2)
.setCachedUsageConsumePower(3)
.setPercentOfTotal(10) .setPercentOfTotal(10)
.setDrainType(1) .setDrainType(1)
.setForegroundUsageTimeInMs(60000) .setForegroundUsageTimeInMs(60000)
.setForegroundServiceUsageTimeInMs(30000)
.setBackgroundUsageTimeInMs(10000) .setBackgroundUsageTimeInMs(10000)
.build(); .build();
} }