diff --git a/src/com/android/settings/fuelgauge/batteryusage/BatteryChartPreferenceController.java b/src/com/android/settings/fuelgauge/batteryusage/BatteryChartPreferenceController.java index 124d4b4296c..90610f8e1c8 100644 --- a/src/com/android/settings/fuelgauge/batteryusage/BatteryChartPreferenceController.java +++ b/src/com/android/settings/fuelgauge/batteryusage/BatteryChartPreferenceController.java @@ -629,6 +629,7 @@ public class BatteryChartPreferenceController extends AbstractPreferenceControll PowerGaugePreference preference, BatteryDiffEntry entry) { final long foregroundUsageTimeInMs = entry.mForegroundUsageTimeInMs; final long backgroundUsageTimeInMs = entry.mBackgroundUsageTimeInMs; + // TODO: update this value after the new API for foreground service is completed. final long totalUsageTimeInMs = foregroundUsageTimeInMs + backgroundUsageTimeInMs; String usageTimeSummary = null; // Not shows summary for some system components without usage time. diff --git a/src/com/android/settings/fuelgauge/batteryusage/BatteryDiffEntry.java b/src/com/android/settings/fuelgauge/batteryusage/BatteryDiffEntry.java index 3fb75c36c56..32711bf21c2 100644 --- a/src/com/android/settings/fuelgauge/batteryusage/BatteryDiffEntry.java +++ b/src/com/android/settings/fuelgauge/batteryusage/BatteryDiffEntry.java @@ -52,8 +52,13 @@ public class BatteryDiffEntry { (a, b) -> Double.compare(b.getPercentOfTotal(), a.getPercentOfTotal()); public long mForegroundUsageTimeInMs; + public long mForegroundServiceUsageTimeInMs; public long mBackgroundUsageTimeInMs; public double mConsumePower; + public double mForegroundUsageConsumePower; + public double mForegroundServiceUsageConsumePower; + public double mBackgroundUsageConsumePower; + public double mCachedUsageConsumePower; // A BatteryHistEntry corresponding to this diff usage data. public final BatteryHistEntry mBatteryHistEntry; @@ -78,12 +83,22 @@ public class BatteryDiffEntry { public BatteryDiffEntry( Context context, long foregroundUsageTimeInMs, + long foregroundServiceUsageTimeInMs, long backgroundUsageTimeInMs, double consumePower, + double foregroundUsageConsumePower, + double foregroundServiceUsageConsumePower, + double backgroundUsageConsumePower, + double cachedUsageConsumePower, BatteryHistEntry batteryHistEntry) { mContext = context; mConsumePower = consumePower; + mForegroundUsageConsumePower = foregroundUsageConsumePower; + mForegroundServiceUsageConsumePower = foregroundServiceUsageConsumePower; + mBackgroundUsageConsumePower = backgroundUsageConsumePower; + mCachedUsageConsumePower = cachedUsageConsumePower; mForegroundUsageTimeInMs = foregroundUsageTimeInMs; + mForegroundServiceUsageTimeInMs = foregroundServiceUsageTimeInMs; mBackgroundUsageTimeInMs = backgroundUsageTimeInMs; mBatteryHistEntry = batteryHistEntry; mUserManager = context.getSystemService(UserManager.class); @@ -106,8 +121,13 @@ public class BatteryDiffEntry { return new BatteryDiffEntry( this.mContext, this.mForegroundUsageTimeInMs, + this.mForegroundServiceUsageTimeInMs, this.mBackgroundUsageTimeInMs, this.mConsumePower, + this.mForegroundUsageConsumePower, + this.mForegroundServiceUsageConsumePower, + this.mBackgroundUsageConsumePower, + this.mCachedUsageConsumePower, this.mBatteryHistEntry /*same instance*/); } @@ -361,10 +381,19 @@ public class BatteryDiffEntry { mAppLabel, mValidForRestriction)) .append(String.format("\n\tconsume=%.2f%% %f/%f", mPercentOfTotal, mConsumePower, mTotalConsumePower)) - .append(String.format("\n\tforeground:%s background:%s", - StringUtil.formatElapsedTime(mContext, mForegroundUsageTimeInMs, + .append(String.format("\n\tconsume power= foreground:%f foregroundService:%f", + 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), - StringUtil.formatElapsedTime(mContext, mBackgroundUsageTimeInMs, + StringUtil.formatElapsedTime( + mContext, + (double) mForegroundServiceUsageTimeInMs, + /*withSeconds=*/ true, + /*collapseTimeUnit=*/ false), + StringUtil.formatElapsedTime(mContext, (double) mBackgroundUsageTimeInMs, /*withSeconds=*/ true, /*collapseTimeUnit=*/ false))) .append(String.format("\n\tpackage:%s|%s uid:%d userId:%d", mBatteryHistEntry.mPackageName, getPackageName(), diff --git a/src/com/android/settings/fuelgauge/batteryusage/BatteryEntry.java b/src/com/android/settings/fuelgauge/batteryusage/BatteryEntry.java index cb870f4d174..36a92486a0c 100644 --- a/src/com/android/settings/fuelgauge/batteryusage/BatteryEntry.java +++ b/src/com/android/settings/fuelgauge/batteryusage/BatteryEntry.java @@ -26,6 +26,7 @@ import android.content.pm.PackageManager.NameNotFoundException; import android.content.pm.UserInfo; import android.graphics.drawable.Drawable; import android.os.BatteryConsumer; +import android.os.BatteryConsumer.Dimensions; import android.os.Process; import android.os.RemoteException; import android.os.UidBatteryConsumer; @@ -39,7 +40,6 @@ import com.android.settings.R; import com.android.settings.fuelgauge.BatteryUtils; import com.android.settingslib.Utils; -import java.util.ArrayList; import java.util.Comparator; import java.util.HashMap; import java.util.Locale; @@ -73,9 +73,24 @@ public class BatteryEntry { private static final String TAG = "BatteryEntry"; private static final String PACKAGE_SYSTEM = "android"; - static final HashMap 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 sRequestQueue = new ArrayList(); + 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 sUidCache = new HashMap<>(); static Locale sCurrentLocale = null; @@ -97,6 +112,7 @@ public class BatteryEntry { private final int mPowerComponentId; private long mUsageDurationMs; private long mTimeInForegroundMs; + private long mTimeInForegroundServiceMs; private long mTimeInBackgroundMs; public String mName; @@ -105,6 +121,10 @@ public class BatteryEntry { public double mPercent; private String mDefaultPackageName; private double mConsumedPower; + private double mConsumedPowerInForeground; + private double mConsumedPowerInForegroundService; + private double mConsumedPowerInBackground; + private double mConsumedPowerInCached; static class UidToDetail { String mName; @@ -156,8 +176,19 @@ public class BatteryEntry { getQuickNameIconForUid(uid, packages, loadDataInBackground); mTimeInForegroundMs = 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 = 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) { mUid = Process.INVALID_UID; mConsumerType = ConvertUtils.CONSUMER_TYPE_USER_BATTERY; @@ -396,7 +427,7 @@ public class BatteryEntry { 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() { if (mBatteryConsumer instanceof UidBatteryConsumer) { 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. */ public long getTimeInBackgroundMs() { if (mBatteryConsumer instanceof UidBatteryConsumer) { @@ -421,6 +461,53 @@ public class BatteryEntry { 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 * uses its package with highest drain, if necessary. @@ -431,8 +518,19 @@ public class BatteryEntry { UidBatteryConsumer uidBatteryConsumer = (UidBatteryConsumer) batteryConsumer; mTimeInForegroundMs += 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 += 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]); if (mDefaultPackageName == null) { mDefaultPackageName = uidBatteryConsumer.getPackageWithHighestDrain(); } @@ -533,4 +631,14 @@ public class BatteryEntry { public static boolean isSystemUid(int 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; + } + } } diff --git a/src/com/android/settings/fuelgauge/batteryusage/BatteryHistEntry.java b/src/com/android/settings/fuelgauge/batteryusage/BatteryHistEntry.java index d26927b25ec..5cd63e80ffa 100644 --- a/src/com/android/settings/fuelgauge/batteryusage/BatteryHistEntry.java +++ b/src/com/android/settings/fuelgauge/batteryusage/BatteryHistEntry.java @@ -50,8 +50,13 @@ public class BatteryHistEntry { // Records the battery usage relative information. public final double mTotalPower; 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 long mForegroundUsageTimeInMs; + public final long mForegroundServiceUsageTimeInMs; public final long mBackgroundUsageTimeInMs; @BatteryConsumer.PowerComponent public final int mDrainType; @@ -79,8 +84,14 @@ public class BatteryHistEntry { mZoneId = batteryInformation.getZoneId(); mTotalPower = batteryInformation.getTotalPower(); mConsumePower = batteryInformation.getConsumePower(); + mForegroundUsageConsumePower = batteryInformation.getForegroundUsageConsumePower(); + mForegroundServiceUsageConsumePower = + batteryInformation.getForegroundServiceUsageConsumePower(); + mBackgroundUsageConsumePower = batteryInformation.getBackgroundUsageConsumePower(); + mCachedUsageConsumePower = batteryInformation.getCachedUsageConsumePower(); mPercentOfTotal = batteryInformation.getPercentOfTotal(); mForegroundUsageTimeInMs = batteryInformation.getForegroundUsageTimeInMs(); + mForegroundServiceUsageTimeInMs = batteryInformation.getForegroundServiceUsageTimeInMs(); mBackgroundUsageTimeInMs = batteryInformation.getBackgroundUsageTimeInMs(); mDrainType = batteryInformation.getDrainType(); final DeviceBatteryState deviceBatteryState = batteryInformation.getDeviceBatteryState(); @@ -103,8 +114,14 @@ public class BatteryHistEntry { mZoneId = batteryInformation.getZoneId(); mTotalPower = batteryInformation.getTotalPower(); mConsumePower = batteryInformation.getConsumePower(); + mForegroundUsageConsumePower = batteryInformation.getForegroundUsageConsumePower(); + mForegroundServiceUsageConsumePower = + batteryInformation.getForegroundServiceUsageConsumePower(); + mBackgroundUsageConsumePower = batteryInformation.getBackgroundUsageConsumePower(); + mCachedUsageConsumePower = batteryInformation.getCachedUsageConsumePower(); mPercentOfTotal = batteryInformation.getPercentOfTotal(); mForegroundUsageTimeInMs = batteryInformation.getForegroundUsageTimeInMs(); + mForegroundServiceUsageTimeInMs = batteryInformation.getForegroundServiceUsageTimeInMs(); mBackgroundUsageTimeInMs = batteryInformation.getBackgroundUsageTimeInMs(); mDrainType = batteryInformation.getDrainType(); final DeviceBatteryState deviceBatteryState = batteryInformation.getDeviceBatteryState(); @@ -119,7 +136,12 @@ public class BatteryHistEntry { long timestamp, double totalPower, double consumePower, + double foregroundUsageConsumePower, + double foregroundServiceUsageConsumePower, + double backgroundUsageConsumePower, + double cachedUsageConsumePower, long foregroundUsageTimeInMs, + long foregroundServiceUsageTimeInMs, long backgroundUsageTimeInMs, int batteryLevel) { mUid = fromEntry.mUid; @@ -132,8 +154,13 @@ public class BatteryHistEntry { mZoneId = fromEntry.mZoneId; mTotalPower = totalPower; mConsumePower = consumePower; + mForegroundUsageConsumePower = foregroundUsageConsumePower; + mForegroundServiceUsageConsumePower = foregroundServiceUsageConsumePower; + mBackgroundUsageConsumePower = backgroundUsageConsumePower; + mCachedUsageConsumePower = cachedUsageConsumePower; mPercentOfTotal = fromEntry.mPercentOfTotal; mForegroundUsageTimeInMs = foregroundUsageTimeInMs; + mForegroundServiceUsageTimeInMs = foregroundServiceUsageTimeInMs; mBackgroundUsageTimeInMs = backgroundUsageTimeInMs; mDrainType = fromEntry.mDrainType; mConsumerType = fromEntry.mConsumerType; @@ -190,9 +217,15 @@ public class BatteryHistEntry { mPackageName, mAppLabel, mUid, mUserId, mIsHidden)) .append(String.format("\n\ttimestamp=%s|zoneId=%s|bootTimestamp=%d", recordAtDateTime, mZoneId, Duration.ofMillis(mBootTimestamp).getSeconds())) - .append(String.format("\n\tusage=%f|total=%f|consume=%f|elapsedTime=%d|%d", - mPercentOfTotal, mTotalPower, mConsumePower, + .append(String.format("\n\tusage=%f|total=%f|consume=%f", + 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(mForegroundServiceUsageTimeInMs).getSeconds(), Duration.ofMillis(mBackgroundUsageTimeInMs).getSeconds())) .append(String.format("\n\tdrainType=%d|consumerType=%d", mDrainType, mConsumerType)) @@ -267,17 +300,45 @@ public class BatteryHistEntry { lowerHistEntry == null ? 0 : lowerHistEntry.mConsumePower, upperHistEntry.mConsumePower, 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( - lowerHistEntry == null ? 0 : lowerHistEntry.mForegroundUsageTimeInMs, - upperHistEntry.mForegroundUsageTimeInMs, + (double) (lowerHistEntry == null ? 0 : lowerHistEntry.mForegroundUsageTimeInMs), + (double) upperHistEntry.mForegroundUsageTimeInMs, + ratio); + final double foregroundServiceUsageTimeInMs = interpolate( + (double) (lowerHistEntry == null + ? 0 + : lowerHistEntry.mForegroundServiceUsageTimeInMs), + (double) upperHistEntry.mForegroundServiceUsageTimeInMs, ratio); final double backgroundUsageTimeInMs = interpolate( - lowerHistEntry == null ? 0 : lowerHistEntry.mBackgroundUsageTimeInMs, - upperHistEntry.mBackgroundUsageTimeInMs, + (double) (lowerHistEntry == null ? 0 : lowerHistEntry.mBackgroundUsageTimeInMs), + (double) upperHistEntry.mBackgroundUsageTimeInMs, ratio); // Checks whether there is any abnormal cases! if (upperHistEntry.mConsumePower < consumePower + || upperHistEntry.mForegroundUsageConsumePower < foregroundUsageConsumePower + || upperHistEntry.mForegroundServiceUsageConsumePower + < foregroundServiceUsageConsumePower + || upperHistEntry.mBackgroundUsageConsumePower < backgroundUsageConsumePower + || upperHistEntry.mCachedUsageConsumePower < cachedUsageConsumePower || upperHistEntry.mForegroundUsageTimeInMs < foregroundUsageTimeInMs + || upperHistEntry.mForegroundServiceUsageTimeInMs < foregroundServiceUsageTimeInMs || upperHistEntry.mBackgroundUsageTimeInMs < backgroundUsageTimeInMs) { if (DEBUG) { Log.w(TAG, String.format( @@ -299,7 +360,12 @@ public class BatteryHistEntry { /*timestamp=*/ slotTimestamp, totalPower, consumePower, + foregroundUsageConsumePower, + foregroundServiceUsageConsumePower, + backgroundUsageConsumePower, + cachedUsageConsumePower, Math.round(foregroundUsageTimeInMs), + Math.round(foregroundServiceUsageTimeInMs), Math.round(backgroundUsageTimeInMs), (int) Math.round(batteryLevel)); } diff --git a/src/com/android/settings/fuelgauge/batteryusage/ConvertUtils.java b/src/com/android/settings/fuelgauge/batteryusage/ConvertUtils.java index ec6e812b521..0c7b4abb1c2 100644 --- a/src/com/android/settings/fuelgauge/batteryusage/ConvertUtils.java +++ b/src/com/android/settings/fuelgauge/batteryusage/ConvertUtils.java @@ -23,46 +23,22 @@ import android.os.BatteryUsageStats; import android.os.Build; import android.os.LocaleList; import android.os.UserHandle; -import android.os.UserManager; import android.text.format.DateFormat; -import android.text.format.DateUtils; -import android.util.ArraySet; import android.util.Base64; -import android.util.Log; import androidx.annotation.VisibleForTesting; -import com.android.settings.Utils; import com.android.settings.fuelgauge.BatteryUtils; -import com.android.settings.overlay.FeatureFactory; import java.lang.annotation.Retention; 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.Map; -import java.util.Set; import java.util.TimeZone; /** A utility class to convert data into another types. */ public final class ConvertUtils { - private static final boolean DEBUG = false; private static final String TAG = "ConvertUtils"; - private static final Map 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. */ public static final String FAKE_PACKAGE_NAME = "fake_package"; @@ -198,167 +174,15 @@ public final class ConvertUtils { return DateFormat.format(pattern, timestamp).toString(); } - /** Gets indexed battery usage data for each corresponding time slot. */ - public static Map> getIndexedUsageMap( - final Context context, - final int timeSlotSize, - final long[] batteryHistoryKeys, - final Map> batteryHistoryMap, - final boolean purgeLowPercentageAndFakeData) { - if (batteryHistoryMap == null || batteryHistoryMap.isEmpty()) { - return new HashMap<>(); - } - final Map> 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 currentBatteryHistMap = - batteryHistoryMap.getOrDefault(currentTimestamp, EMPTY_BATTERY_MAP); - final Map nextBatteryHistMap = - batteryHistoryMap.getOrDefault(nextTimestamp, EMPTY_BATTERY_MAP); - final Map 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()); - continue; - } - - // Collects all keys in these three time slot records as all populations. - final Set allBatteryHistEntryKeys = new ArraySet<>(); - allBatteryHistEntryKeys.addAll(currentBatteryHistMap.keySet()); - allBatteryHistEntryKeys.addAll(nextBatteryHistMap.keySet()); - allBatteryHistEntryKeys.addAll(nextTwoBatteryHistMap.keySet()); - - double totalConsumePower = 0.0; - final List 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 - static void resolveMultiUsersData( - final Context context, - final Map> indexedUsageMap) { - 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 entryList : indexedUsageMap.values()) { - double consumePowerFromOtherUsers = 0f; - double consumePercentageFromOtherUsers = 0f; - final Iterator 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)); - } + 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 BatteryInformation constructBatteryInformation( @@ -387,121 +211,18 @@ public final class ConvertUtils { .setAppLabel(entry.getLabel() != null ? entry.getLabel() : "") .setTotalPower(batteryUsageStats.getConsumedPower()) .setConsumePower(entry.getConsumedPower()) + .setForegroundUsageConsumePower(entry.getConsumedPowerInForeground()) + .setForegroundServiceUsageConsumePower( + entry.getConsumedPowerInForegroundService()) + .setBackgroundUsageConsumePower(entry.getConsumedPowerInBackground()) + .setCachedUsageConsumePower(entry.getConsumedPowerInCached()) .setPercentOfTotal(entry.mPercent) .setDrainType(entry.getPowerComponentId()) .setForegroundUsageTimeInMs(entry.getTimeInForegroundMs()) + .setForegroundServiceUsageTimeInMs(entry.getTimeInForegroundServiceMs()) .setBackgroundUsageTimeInMs(entry.getTimeInBackgroundMs()); } return batteryInformationBuilder.build(); } - - private static void insert24HoursData( - final int desiredIndex, - final Map> indexedUsageMap) { - final Map resultMap = new HashMap<>(); - double totalConsumePower = 0f; - // Loops for all BatteryDiffEntry and aggregate them together. - for (List 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 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> indexedUsageMap) { - final Set backgroundUsageTimeHideList = - FeatureFactory.getFactory(context) - .getPowerUsageFeatureProvider(context) - .getHideBackgroundUsageTimeSet(context); - for (List entries : indexedUsageMap.values()) { - final Iterator 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; - } } diff --git a/src/com/android/settings/fuelgauge/batteryusage/DataProcessor.java b/src/com/android/settings/fuelgauge/batteryusage/DataProcessor.java index 14d6ea912db..0a4ac7c477f 100644 --- a/src/com/android/settings/fuelgauge/batteryusage/DataProcessor.java +++ b/src/com/android/settings/fuelgauge/batteryusage/DataProcessor.java @@ -87,9 +87,6 @@ public final class DataProcessor { @VisibleForTesting 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. */ public interface UsageMapAsyncResponse { /** The callback function when batteryUsageMap is loaded. */ @@ -174,7 +171,11 @@ public final class DataProcessor { @Nullable public static BatteryUsageStats getBatteryUsageStats(final Context context) { final BatteryUsageStatsQuery batteryUsageStatsQuery = - new BatteryUsageStatsQuery.Builder().includeBatteryHistory().build(); + new BatteryUsageStatsQuery + .Builder() + .includeBatteryHistory() + .includeProcessStateData() + .build(); return context.getSystemService(BatteryStatsManager.class) .getBatteryUsageStats(batteryUsageStatsQuery); } @@ -478,8 +479,13 @@ public final class DataProcessor { final BatteryDiffEntry currentBatteryDiffEntry = new BatteryDiffEntry( context, entry.mForegroundUsageTimeInMs, + entry.mForegroundServiceUsageTimeInMs, entry.mBackgroundUsageTimeInMs, entry.mConsumePower, + entry.mForegroundUsageConsumePower, + entry.mForegroundServiceUsageConsumePower, + entry.mBackgroundUsageConsumePower, + entry.mCachedUsageConsumePower, entry); if (currentBatteryDiffEntry.isSystemEntry()) { systemEntries.add(currentBatteryDiffEntry); @@ -567,10 +573,12 @@ public final class DataProcessor { return batteryEntryList.stream() .filter(entry -> { final long foregroundMs = entry.getTimeInForegroundMs(); + final long foregroundServiceMs = entry.getTimeInForegroundServiceMs(); final long backgroundMs = entry.getTimeInBackgroundMs(); return entry.getConsumedPower() > 0 || (entry.getConsumedPower() == 0 - && (foregroundMs != 0 || backgroundMs != 0)); + && (foregroundMs != 0 || foregroundServiceMs != 0 + || backgroundMs != 0)); }) .map(entry -> ConvertUtils.convertToBatteryHistEntry( entry, @@ -691,9 +699,14 @@ public final class DataProcessor { if (lowerEntry != null) { final boolean invalidForegroundUsageTime = lowerEntry.mForegroundUsageTimeInMs > upperEntry.mForegroundUsageTimeInMs; + final boolean invalidForegroundServiceUsageTime = + lowerEntry.mForegroundServiceUsageTimeInMs + > upperEntry.mForegroundServiceUsageTimeInMs; final boolean invalidBackgroundUsageTime = lowerEntry.mBackgroundUsageTimeInMs > upperEntry.mBackgroundUsageTimeInMs; - if (invalidForegroundUsageTime || invalidBackgroundUsageTime) { + if (invalidForegroundUsageTime + || invalidForegroundServiceUsageTime + || invalidBackgroundUsageTime) { newHistEntryMap.put(entryKey, upperEntry); log(context, "abnormal reset condition is found", currentSlot, upperEntry); continue; @@ -924,6 +937,11 @@ public final class DataProcessor { currentEntry.mForegroundUsageTimeInMs, nextEntry.mForegroundUsageTimeInMs, nextTwoEntry.mForegroundUsageTimeInMs); + long foregroundServiceUsageTimeInMs = + getDiffValue( + currentEntry.mForegroundServiceUsageTimeInMs, + nextEntry.mForegroundServiceUsageTimeInMs, + nextTwoEntry.mForegroundServiceUsageTimeInMs); long backgroundUsageTimeInMs = getDiffValue( currentEntry.mBackgroundUsageTimeInMs, @@ -934,8 +952,29 @@ public final class DataProcessor { currentEntry.mConsumePower, nextEntry.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. if (foregroundUsageTimeInMs == 0 + && foregroundServiceUsageTimeInMs == 0 && backgroundUsageTimeInMs == 0 && consumePower == 0) { continue; @@ -947,6 +986,7 @@ public final class DataProcessor { } // Forces refine the cumulative value since it may introduce deviation error since we // will apply the interpolation arithmetic. + // TODO: update this value after the new API for foreground service is completed. final float totalUsageTimeInMs = foregroundUsageTimeInMs + backgroundUsageTimeInMs; if (totalUsageTimeInMs > TOTAL_HOURLY_TIME_THRESHOLD) { @@ -959,9 +999,15 @@ public final class DataProcessor { } foregroundUsageTimeInMs = Math.round(foregroundUsageTimeInMs * ratio); + foregroundServiceUsageTimeInMs = + Math.round(foregroundServiceUsageTimeInMs * ratio); backgroundUsageTimeInMs = Math.round(backgroundUsageTimeInMs * ratio); consumePower = consumePower * ratio; + foregroundUsageConsumePower = foregroundUsageConsumePower * ratio; + foregroundServiceUsageConsumePower = foregroundServiceUsageConsumePower * ratio; + backgroundUsageConsumePower = backgroundUsageConsumePower * ratio; + cachedUsageConsumePower = cachedUsageConsumePower * ratio; } totalConsumePower += consumePower; @@ -973,8 +1019,13 @@ public final class DataProcessor { final BatteryDiffEntry currentBatteryDiffEntry = new BatteryDiffEntry( context, foregroundUsageTimeInMs, + foregroundServiceUsageTimeInMs, backgroundUsageTimeInMs, consumePower, + foregroundUsageConsumePower, + foregroundServiceUsageConsumePower, + backgroundUsageConsumePower, + cachedUsageConsumePower, selectedBatteryEntry); if (currentBatteryDiffEntry.isSystemEntry()) { systemEntries.add(currentBatteryDiffEntry); @@ -1054,9 +1105,16 @@ public final class DataProcessor { // Sums up some field data into the existing one. oldBatteryDiffEntry.mForegroundUsageTimeInMs += entry.mForegroundUsageTimeInMs; + oldBatteryDiffEntry.mForegroundServiceUsageTimeInMs += + entry.mForegroundServiceUsageTimeInMs; oldBatteryDiffEntry.mBackgroundUsageTimeInMs += entry.mBackgroundUsageTimeInMs; 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 String packageName = entry.getPackageName(); if (entry.getPercentOfTotal() < PERCENTAGE_OF_TOTAL_THRESHOLD - || FAKE_PACKAGE_NAME.equals(packageName) + || ConvertUtils.FAKE_PACKAGE_NAME.equals(packageName) || contains(packageName, notAllowShowEntryPackages)) { iterator.remove(); } @@ -1346,8 +1404,13 @@ public final class DataProcessor { final BatteryDiffEntry batteryDiffEntry = new BatteryDiffEntry( context, /*foregroundUsageTimeInMs=*/ 0, + /*foregroundServiceUsageTimeInMs=*/ 0, /*backgroundUsageTimeInMs=*/ 0, consumePower, + /*foregroundUsageConsumePower=*/ 0, + /*foregroundServiceUsageConsumePower=*/ 0, + /*backgroundUsageConsumePower=*/ 0, + /*cachedUsageConsumePower=*/ 0, new BatteryHistEntry(values)); return batteryDiffEntry; } diff --git a/src/com/android/settings/fuelgauge/batteryusage/DatabaseUtils.java b/src/com/android/settings/fuelgauge/batteryusage/DatabaseUtils.java index 4b468011766..3cab8b2e181 100644 --- a/src/com/android/settings/fuelgauge/batteryusage/DatabaseUtils.java +++ b/src/com/android/settings/fuelgauge/batteryusage/DatabaseUtils.java @@ -164,15 +164,20 @@ public final class DatabaseUtils { batteryEntryList.stream() .filter(entry -> { final long foregroundMs = entry.getTimeInForegroundMs(); + final long foregroundServiceMs = entry.getTimeInForegroundServiceMs(); final long backgroundMs = entry.getTimeInBackgroundMs(); if (entry.getConsumedPower() == 0 - && (foregroundMs != 0 || backgroundMs != 0)) { + && (foregroundMs != 0 + || foregroundServiceMs != 0 + || backgroundMs != 0)) { Log.w(TAG, String.format( - "no consumed power but has running time for %s time=%d|%d", - entry.getLabel(), foregroundMs, backgroundMs)); + "no consumed power but has running time for %s time=%d|%d|%d", + entry.getLabel(), foregroundMs, foregroundServiceMs, + backgroundMs)); } return entry.getConsumedPower() != 0 || foregroundMs != 0 + || foregroundServiceMs != 0 || backgroundMs != 0; }) .forEach(entry -> valuesList.add( diff --git a/tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryChartPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryChartPreferenceControllerTest.java index fad5c2c3826..5c84997349f 100644 --- a/tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryChartPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryChartPreferenceControllerTest.java @@ -127,8 +127,13 @@ public final class BatteryChartPreferenceControllerTest { mBatteryDiffEntry = new BatteryDiffEntry( mContext, /*foregroundUsageTimeInMs=*/ 1, + /*foregroundServiceUsageTimeInMs=*/ 3, /*backgroundUsageTimeInMs=*/ 2, /*consumePower=*/ 3, + /*foregroundUsageConsumePower=*/ 0, + /*foregroundServiceUsageConsumePower=*/ 1, + /*backgroundUsageConsumePower=*/ 2, + /*cachedUsageConsumePower=*/ 0, mBatteryHistEntry); mBatteryDiffEntry = spy(mBatteryDiffEntry); // Adds fake testing data. @@ -458,6 +463,7 @@ public final class BatteryChartPreferenceControllerTest { mBatteryChartPreferenceController.setPreferenceSummary( pref, createBatteryDiffEntry( /*foregroundUsageTimeInMs=*/ 0, + /*foregroundServiceUsageTimeInMs=*/ 0, /*backgroundUsageTimeInMs=*/ 0)); assertThat(pref.getSummary()).isNull(); } @@ -470,6 +476,7 @@ public final class BatteryChartPreferenceControllerTest { mBatteryChartPreferenceController.setPreferenceSummary( pref, createBatteryDiffEntry( /*foregroundUsageTimeInMs=*/ 0, + /*foregroundServiceUsageTimeInMs=*/ 0, /*backgroundUsageTimeInMs=*/ DateUtils.MINUTE_IN_MILLIS)); assertThat(pref.getSummary()).isEqualTo("Background: 1 min"); } @@ -482,6 +489,7 @@ public final class BatteryChartPreferenceControllerTest { mBatteryChartPreferenceController.setPreferenceSummary( pref, createBatteryDiffEntry( /*foregroundUsageTimeInMs=*/ 100, + /*foregroundServiceUsageTimeInMs=*/ 200, /*backgroundUsageTimeInMs=*/ 200)); assertThat(pref.getSummary()).isEqualTo("Total: less than a min"); } @@ -494,6 +502,7 @@ public final class BatteryChartPreferenceControllerTest { mBatteryChartPreferenceController.setPreferenceSummary( pref, createBatteryDiffEntry( /*foregroundUsageTimeInMs=*/ DateUtils.MINUTE_IN_MILLIS, + /*foregroundServiceUsageTimeInMs=*/ 100, /*backgroundUsageTimeInMs=*/ 200)); assertThat(pref.getSummary()) .isEqualTo("Total: 1 min\nBackground: less than a min"); @@ -507,6 +516,7 @@ public final class BatteryChartPreferenceControllerTest { mBatteryChartPreferenceController.setPreferenceSummary( pref, createBatteryDiffEntry( /*foregroundUsageTimeInMs=*/ DateUtils.MINUTE_IN_MILLIS, + /*foregroundServiceUsageTimeInMs=*/ DateUtils.MINUTE_IN_MILLIS, /*backgroundUsageTimeInMs=*/ DateUtils.MINUTE_IN_MILLIS)); assertThat(pref.getSummary()).isEqualTo("Total: 2 min\nBackground: 1 min"); } @@ -717,10 +727,13 @@ public final class BatteryChartPreferenceControllerTest { } private BatteryDiffEntry createBatteryDiffEntry( - long foregroundUsageTimeInMs, long backgroundUsageTimeInMs) { + long foregroundUsageTimeInMs, long foregroundServiceUsageTimeInMs, + long backgroundUsageTimeInMs) { return new BatteryDiffEntry( - mContext, foregroundUsageTimeInMs, backgroundUsageTimeInMs, - /*consumePower=*/ 0, mBatteryHistEntry); + mContext, foregroundUsageTimeInMs, foregroundServiceUsageTimeInMs, + backgroundUsageTimeInMs, /*consumePower=*/ 0, /*foregroundUsageConsumePower=*/ 0, + /*foregroundServiceUsageConsumePower=*/ 0, /*backgroundUsageConsumePower=*/ 0, + /*cachedUsageConsumePower=*/ 0, mBatteryHistEntry); } private BatteryChartPreferenceController createController() { diff --git a/tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryDiffEntryTest.java b/tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryDiffEntryTest.java index 79c5a1c5708..00904366c74 100644 --- a/tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryDiffEntryTest.java +++ b/tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryDiffEntryTest.java @@ -96,8 +96,13 @@ public final class BatteryDiffEntryTest { new BatteryDiffEntry( mContext, /*foregroundUsageTimeInMs=*/ 10001L, + /*foregroundServiceUsageTimeInMs=*/ 10002L, /*backgroundUsageTimeInMs=*/ 20002L, /*consumePower=*/ 22.0, + /*foregroundUsageConsumePower=*/ 10.0, + /*foregroundServiceUsageConsumePower=*/ 10.0, + /*backgroundUsageConsumePower=*/ 1.0, + /*cachedUsageConsumePower=*/ 1.0, /*batteryHistEntry=*/ null); entry.setTotalConsumePower(100.0); @@ -110,8 +115,13 @@ public final class BatteryDiffEntryTest { new BatteryDiffEntry( mContext, /*foregroundUsageTimeInMs=*/ 10001L, + /*foregroundServiceUsageTimeInMs=*/ 10002L, /*backgroundUsageTimeInMs=*/ 20002L, /*consumePower=*/ 22.0, + /*foregroundUsageConsumePower=*/ 10.0, + /*foregroundServiceUsageConsumePower=*/ 10.0, + /*backgroundUsageConsumePower=*/ 1.0, + /*cachedUsageConsumePower=*/ 1.0, /*batteryHistEntry=*/ null); entry.setTotalConsumePower(0); @@ -483,8 +493,13 @@ public final class BatteryDiffEntryTest { return new BatteryDiffEntry( mContext, /*foregroundUsageTimeInMs=*/ 0, + /*foregroundServiceUsageTimeInMs=*/ 0, /*backgroundUsageTimeInMs=*/ 0, /*consumePower=*/ 0, + /*foregroundUsageConsumePower=*/ 0, + /*foregroundServiceUsageConsumePower=*/ 0, + /*backgroundUsageConsumePower=*/ 0, + /*cachedUsageConsumePower=*/ 0, new BatteryHistEntry(values)); } @@ -493,8 +508,13 @@ public final class BatteryDiffEntryTest { final BatteryDiffEntry entry = new BatteryDiffEntry( mContext, /*foregroundUsageTimeInMs=*/ 0, + /*foregroundServiceUsageTimeInMs=*/ 0, /*backgroundUsageTimeInMs=*/ 0, consumePower, + /*foregroundUsageConsumePower=*/ 0, + /*foregroundServiceUsageConsumePower=*/ 0, + /*backgroundUsageConsumePower=*/ 0, + /*cachedUsageConsumePower=*/ 0, batteryHistEntry); entry.setTotalConsumePower(100.0); return entry; diff --git a/tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryHistEntryTest.java b/tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryHistEntryTest.java index 21dc79b8861..848265a5d09 100644 --- a/tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryHistEntryTest.java +++ b/tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryHistEntryTest.java @@ -57,8 +57,13 @@ public final class BatteryHistEntryTest { when(mMockBatteryEntry.isHidden()).thenReturn(true); when(mBatteryUsageStats.getConsumedPower()).thenReturn(5.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; when(mMockBatteryEntry.getTimeInForegroundMs()).thenReturn(1234L); + when(mMockBatteryEntry.getTimeInForegroundServiceMs()).thenReturn(3456L); when(mMockBatteryEntry.getTimeInBackgroundMs()).thenReturn(5689L); when(mMockBatteryEntry.getPowerComponentId()).thenReturn(expectedType); when(mMockBatteryEntry.getConsumerType()) @@ -94,7 +99,12 @@ public final class BatteryHistEntryTest { /*timestamp=*/ 10001L, /*totalPower=*/ 5.1, /*consumePower=*/ 1.1, + /*foregroundUsageConsumePower=*/ 1.2, + /*foregroundServiceUsageConsumePower=*/ 1.3, + /*backgroundUsageConsumePower=*/ 1.4, + /*cachedUsageConsumePower=*/ 1.5, /*foregroundUsageTimeInMs=*/ 1234L, + /*foregroundServiceUsageTimeInMs=*/ 3456L, /*backgroundUsageTimeInMs=*/ 5689L, /*batteryLevel=*/ 12), /*drainType=*/ 3, @@ -178,7 +188,12 @@ public final class BatteryHistEntryTest { lowerTimestamp, /*totalPower=*/ 50, /*consumePower=*/ 10, + /*foregroundUsageConsumePower=*/ 1, + /*foregroundServiceUsageConsumePower=*/ 2, + /*backgroundUsageConsumePower=*/ 3, + /*cachedUsageConsumePower=*/ 4, /*foregroundUsageTimeInMs=*/ 100, + /*foregroundServiceUsageTimeInMs=*/ 150, /*backgroundUsageTimeInMs=*/ 200, /*batteryLevel=*/ 90); final BatteryHistEntry upperHistEntry = createBatteryHistEntry( @@ -186,7 +201,12 @@ public final class BatteryHistEntryTest { upperTimestamp, /*totalPower=*/ 80, /*consumePower=*/ 20, + /*foregroundUsageConsumePower=*/ 4, + /*foregroundServiceUsageConsumePower=*/ 5, + /*backgroundUsageConsumePower=*/ 6, + /*cachedUsageConsumePower=*/ 5, /*foregroundUsageTimeInMs=*/ 200, + /*foregroundServiceUsageTimeInMs=*/ 250, /*backgroundUsageTimeInMs=*/ 300, /*batteryLevel=*/ 80); @@ -204,7 +224,12 @@ public final class BatteryHistEntryTest { /*timestamp=*/ slotTimestamp, /*totalPower=*/ 50 + 0.5 * (80 - 50), /*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)), + /*foregroundServiceUsageTimeInMs=*/ Math.round(150 + 0.5 * (250 - 150)), /*backgroundUsageTimeInMs=*/ Math.round(200 + 0.5 * (300 - 200)), /*batteryLevel=*/ (int) Math.round(90 + 0.5 * (80 - 90))); } @@ -213,14 +238,18 @@ public final class BatteryHistEntryTest { public void testInterpolate_withoutLowerEntryData_returnExpectedResult() { final long slotTimestamp = 200L; final long upperTimestamp = 300L; - final long lowerTimestamp = 100L; final double ratio = 0.5; final BatteryHistEntry upperHistEntry = createBatteryHistEntry( /*bootTimestamp=*/ 1200L, upperTimestamp, /*totalPower=*/ 80, /*consumePower=*/ 20, + /*foregroundUsageConsumePower=*/ 4, + /*foregroundServiceUsageConsumePower=*/ 5, + /*backgroundUsageConsumePower=*/ 6, + /*cachedUsageConsumePower=*/ 5, /*foregroundUsageTimeInMs=*/ 200, + /*foregroundServiceUsageTimeInMs=*/ 250, /*backgroundUsageTimeInMs=*/ 300, /*batteryLevel=*/ 80); @@ -238,7 +267,12 @@ public final class BatteryHistEntryTest { /*timestamp=*/ slotTimestamp, /*totalPower=*/ 0.5 * 80, /*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), + /*foregroundServiceUsageTimeInMs=*/ Math.round(0.5 * 250), /*backgroundUsageTimeInMs=*/ Math.round(0.5 * 300), /*batteryLevel=*/ upperHistEntry.mBatteryLevel); } @@ -262,7 +296,12 @@ public final class BatteryHistEntryTest { /*timestamp=*/ 10001L, /*totalPower=*/ 5.1, /*consumePower=*/ 1.1, + /*foregroundUsageConsumePower=*/ 1.2, + /*foregroundServiceUsageConsumePower=*/ 1.3, + /*backgroundUsageConsumePower=*/ 1.4, + /*cachedUsageConsumePower=*/ 1.5, /*foregroundUsageTimeInMs=*/ 1234L, + /*foregroundServiceUsageTimeInMs=*/ 3456L, /*backgroundUsageTimeInMs=*/ 5689L, /*batteryLevel=*/ 12); } @@ -275,7 +314,12 @@ public final class BatteryHistEntryTest { long timestamp, double totalPower, double consumePower, + double foregroundUsageConsumePower, + double foregroundServiceUsageConsumePower, + double backgroundUsageConsumePower, + double cachedUsageConsumePower, long foregroundUsageTimeInMs, + long foregroundServiceUsageTimeInMs, long backgroundUsageTimeInMs, int batteryLevel) { assertThat(entry.isValidEntry()).isTrue(); @@ -290,8 +334,15 @@ public final class BatteryHistEntryTest { assertThat(entry.mZoneId).isEqualTo(TimeZone.getDefault().getID()); assertThat(entry.mTotalPower).isEqualTo(totalPower); 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.mForegroundUsageTimeInMs).isEqualTo(foregroundUsageTimeInMs); + assertThat(entry.mForegroundServiceUsageTimeInMs) + .isEqualTo(foregroundServiceUsageTimeInMs); assertThat(entry.mBackgroundUsageTimeInMs).isEqualTo(backgroundUsageTimeInMs); assertThat(entry.mDrainType).isEqualTo(drainType); assertThat(entry.mConsumerType) @@ -308,7 +359,12 @@ public final class BatteryHistEntryTest { long timestamp, double totalPower, double consumePower, + double foregroundUsageConsumePower, + double foregroundServiceUsageConsumePower, + double backgroundUsageConsumePower, + double cachedUsageConsumePower, long foregroundUsageTimeInMs, + long foregroundServiceUsageTimeInMs, long backgroundUsageTimeInMs, int batteryLevel) { final MatrixCursor cursor = new MatrixCursor( @@ -336,9 +392,14 @@ public final class BatteryHistEntryTest { .setAppLabel("Settings") .setTotalPower(totalPower) .setConsumePower(consumePower) + .setForegroundUsageConsumePower(foregroundUsageConsumePower) + .setForegroundServiceUsageConsumePower(foregroundServiceUsageConsumePower) + .setBackgroundUsageConsumePower(backgroundUsageConsumePower) + .setCachedUsageConsumePower(cachedUsageConsumePower) .setPercentOfTotal(0.3) .setDrainType(3) .setForegroundUsageTimeInMs(foregroundUsageTimeInMs) + .setForegroundServiceUsageTimeInMs(foregroundServiceUsageTimeInMs) .setBackgroundUsageTimeInMs(backgroundUsageTimeInMs) .build(); cursor.addRow( diff --git a/tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryUsageContentProviderTest.java b/tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryUsageContentProviderTest.java index 4b596a6ae22..d6e7737a21b 100644 --- a/tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryUsageContentProviderTest.java +++ b/tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryUsageContentProviderTest.java @@ -196,8 +196,13 @@ public final class BatteryUsageContentProviderTest { .setBootTimestamp(101L) .setTotalPower(99) .setConsumePower(9) + .setForegroundUsageConsumePower(1) + .setForegroundServiceUsageConsumePower(2) + .setBackgroundUsageConsumePower(3) + .setCachedUsageConsumePower(3) .setPercentOfTotal(0.9) .setForegroundUsageTimeInMs(1000) + .setForegroundServiceUsageTimeInMs(1500) .setBackgroundUsageTimeInMs(2000) .setDrainType(1) .build(); diff --git a/tests/robotests/src/com/android/settings/fuelgauge/batteryusage/ConvertUtilsTest.java b/tests/robotests/src/com/android/settings/fuelgauge/batteryusage/ConvertUtilsTest.java index 9ea8ced3b13..9a4355724e9 100644 --- a/tests/robotests/src/com/android/settings/fuelgauge/batteryusage/ConvertUtilsTest.java +++ b/tests/robotests/src/com/android/settings/fuelgauge/batteryusage/ConvertUtilsTest.java @@ -26,11 +26,6 @@ import android.os.BatteryManager; import android.os.BatteryUsageStats; import android.os.LocaleList; 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.Test; @@ -40,13 +35,7 @@ import org.mockito.MockitoAnnotations; import org.robolectric.RobolectricTestRunner; 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.Map; import java.util.TimeZone; @RunWith(RobolectricTestRunner.class) @@ -59,15 +48,10 @@ public final class ConvertUtilsTest { @Mock private BatteryEntry mMockBatteryEntry; - private FakeFeatureFactory mFeatureFactory; - private PowerUsageFeatureProvider mPowerUsageFeatureProvider; - @Before public void setUp() { MockitoAnnotations.initMocks(this); mContext = spy(RuntimeEnvironment.application); - mFeatureFactory = FakeFeatureFactory.setupForTest(); - mPowerUsageFeatureProvider = mFeatureFactory.powerUsageFeatureProvider; } @Test @@ -80,8 +64,13 @@ public final class ConvertUtilsTest { when(mMockBatteryEntry.isHidden()).thenReturn(true); when(mBatteryUsageStats.getConsumedPower()).thenReturn(5.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; when(mMockBatteryEntry.getTimeInForegroundMs()).thenReturn(1234L); + when(mMockBatteryEntry.getTimeInForegroundServiceMs()).thenReturn(3456L); when(mMockBatteryEntry.getTimeInBackgroundMs()).thenReturn(5689L); when(mMockBatteryEntry.getPowerComponentId()).thenReturn(expectedType); when(mMockBatteryEntry.getConsumerType()) @@ -117,8 +106,13 @@ public final class ConvertUtilsTest { assertThat(batteryInformation.getZoneId()).isEqualTo(TimeZone.getDefault().getID()); assertThat(batteryInformation.getTotalPower()).isEqualTo(5.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.getForegroundUsageTimeInMs()).isEqualTo(1234L); + assertThat(batteryInformation.getForegroundServiceUsageTimeInMs()).isEqualTo(3456L); assertThat(batteryInformation.getBackgroundUsageTimeInMs()).isEqualTo(5689L); assertThat(batteryInformation.getDrainType()).isEqualTo(expectedType); assertThat(deviceBatteryState.getBatteryLevel()).isEqualTo(12); @@ -169,8 +163,13 @@ public final class ConvertUtilsTest { when(mMockBatteryEntry.isHidden()).thenReturn(true); when(mBatteryUsageStats.getConsumedPower()).thenReturn(5.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; when(mMockBatteryEntry.getTimeInForegroundMs()).thenReturn(1234L); + when(mMockBatteryEntry.getTimeInForegroundServiceMs()).thenReturn(3456L); when(mMockBatteryEntry.getTimeInBackgroundMs()).thenReturn(5689L); when(mMockBatteryEntry.getPowerComponentId()).thenReturn(expectedType); when(mMockBatteryEntry.getConsumerType()) @@ -196,9 +195,15 @@ public final class ConvertUtilsTest { .isEqualTo(TimeZone.getDefault().getID()); assertThat(batteryHistEntry.mTotalPower).isEqualTo(5.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.mForegroundUsageTimeInMs) .isEqualTo(1234L); + assertThat(batteryHistEntry.mForegroundServiceUsageTimeInMs) + .isEqualTo(3456L); assertThat(batteryHistEntry.mBackgroundUsageTimeInMs) .isEqualTo(5689L); assertThat(batteryHistEntry.mDrainType).isEqualTo(expectedType); @@ -229,194 +234,6 @@ public final class ConvertUtilsTest { .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>(), - /*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> batteryHistoryMap = - new HashMap<>(); - final BatteryHistEntry fakeEntry = createBatteryHistEntry( - ConvertUtils.FAKE_PACKAGE_NAME, "fake_label", 0, 0L, 0L, 0L); - // Adds the index = 0 data. - Map 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> resultMap = - ConvertUtils.getIndexedUsageMap( - mContext, timeSlotSize, batteryHistoryKeys, batteryHistoryMap, - /*purgeLowPercentageAndFakeData=*/ false); - - assertThat(resultMap).hasSize(3); - // Verifies the first timestamp result. - List 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> 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> batteryHistoryMap = - new HashMap<>(); - final BatteryHistEntry fakeEntry = createBatteryHistEntry( - ConvertUtils.FAKE_PACKAGE_NAME, "fake_label", 0, 0L, 0L, 0L); - // Adds the index = 0 data. - Map 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> purgedResultMap = - ConvertUtils.getIndexedUsageMap( - mContext, timeSlotSize, batteryHistoryKeys, batteryHistoryMap, - /*purgeLowPercentageAndFakeData=*/ true); - - assertThat(purgedResultMap).hasSize(2); - final List 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> batteryHistoryMap = new HashMap<>(); - final BatteryHistEntry fakeEntry = createBatteryHistEntry( - ConvertUtils.FAKE_PACKAGE_NAME, "fake_label", 0, 0L, 0L, 0L); - // Adds the index = 0 data. - Map 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> purgedResultMap = - ConvertUtils.getIndexedUsageMap( - mContext, /*timeSlotSize=*/ 1, batteryHistoryKeys, batteryHistoryMap, - /*purgeLowPercentageAndFakeData=*/ true); - - final BatteryDiffEntry resultEntry = purgedResultMap.get(0).get(0); - assertThat(resultEntry.mBackgroundUsageTimeInMs).isEqualTo(0); - } - @Test public void getLocale_nullContext_returnDefaultLocale() { assertThat(ConvertUtils.getLocale(/*context=*/ null)) @@ -434,113 +251,4 @@ public final class ConvertUtilsTest { mContext.getResources().getConfiguration().setLocales(new LocaleList()); assertThat(ConvertUtils.getLocale(mContext)).isEqualTo(Locale.getDefault()); } - - @Test - public void resolveMultiUsersData_replaceOtherUsersItemWithExpectedEntry() { - final int currentUserId = mContext.getUserId(); - final Map> 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 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 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; - } } diff --git a/tests/robotests/src/com/android/settings/fuelgauge/batteryusage/DataProcessorTest.java b/tests/robotests/src/com/android/settings/fuelgauge/batteryusage/DataProcessorTest.java index 7d68140068f..cdfed06f446 100644 --- a/tests/robotests/src/com/android/settings/fuelgauge/batteryusage/DataProcessorTest.java +++ b/tests/robotests/src/com/android/settings/fuelgauge/batteryusage/DataProcessorTest.java @@ -532,15 +532,21 @@ public class DataProcessorTest { final Map> batteryHistoryMap = new HashMap<>(); final int currentUserId = mContext.getUserId(); final BatteryHistEntry fakeEntry = createBatteryHistEntry( - ConvertUtils.FAKE_PACKAGE_NAME, "fake_label", /*consumePower=*/ 0, /*uid=*/ 0L, - currentUserId, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, - /*foregroundUsageTimeInMs=*/ 0L, /*backgroundUsageTimeInMs=*/ 0L); + ConvertUtils.FAKE_PACKAGE_NAME, "fake_label", /*consumePower=*/ 0, + /*foregroundUsageConsumePower=*/ 0, /*foregroundServiceUsageConsumePower=*/ 0, + /*backgroundUsageConsumePower=*/ 0, /*cachedUsageConsumePower=*/ 0, + /*uid=*/ 0L, currentUserId, ConvertUtils.CONSUMER_TYPE_UID_BATTERY, + /*foregroundUsageTimeInMs=*/ 0L, /*foregroundServiceUsageTimeInMs=*/ 0L, + /*backgroundUsageTimeInMs=*/ 0L); // Adds the index = 0 data. Map entryMap = new HashMap<>(); 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, - /*backgroundUsageTimeInMs=*/ 20L); + /*foregroundServiceUsageTimeInMs=*/ 10L, /*backgroundUsageTimeInMs=*/ 20L); entryMap.put(entry.getKey(), entry); entryMap.put(fakeEntry.getKey(), fakeEntry); batteryHistoryMap.put(batteryHistoryKeys[0], entryMap); @@ -551,47 +557,68 @@ public class DataProcessorTest { // Adds the index = 2 data. entryMap = new HashMap<>(); 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, - 25L); + /*foregroundServiceUsageTimeInMs=*/ 15L, /*backgroundUsageTimeInMs=*/ 25L); entryMap.put(entry.getKey(), entry); entryMap.put(fakeEntry.getKey(), fakeEntry); batteryHistoryMap.put(batteryHistoryKeys[2], entryMap); // Adds the index = 3 data. entryMap = new HashMap<>(); 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, - /*backgroundUsageTimeInMs=*/ 35L); + /*foregroundServiceUsageTimeInMs=*/ 25L, /*backgroundUsageTimeInMs=*/ 35L); entryMap.put(entry.getKey(), entry); 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, - /*backgroundUsageTimeInMs=*/ 50L); + /*foregroundServiceUsageTimeInMs=*/ 40L, /*backgroundUsageTimeInMs=*/ 50L); entryMap.put(entry.getKey(), entry); 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, - /*backgroundUsageTimeInMs=*/ 5L); + /*foregroundServiceUsageTimeInMs=*/ 5L, /*backgroundUsageTimeInMs=*/ 5L); entryMap.put(entry.getKey(), entry); entryMap.put(fakeEntry.getKey(), fakeEntry); batteryHistoryMap.put(batteryHistoryKeys[3], entryMap); // Adds the index = 4 data. entryMap = new HashMap<>(); 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, - /*backgroundUsageTimeInMs=*/ 40L); + /*foregroundServiceUsageTimeInMs=*/ 30L, /*backgroundUsageTimeInMs=*/ 40L); entryMap.put(entry.getKey(), entry); 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, - /*backgroundUsageTimeInMs=*/ 60L); + /*foregroundServiceUsageTimeInMs=*/ 50L, /*backgroundUsageTimeInMs=*/ 60L); entryMap.put(entry.getKey(), entry); 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, - /*backgroundUsageTimeInMs=*/ 5L); + /*foregroundServiceUsageTimeInMs=*/ 5L, /*backgroundUsageTimeInMs=*/ 5L); entryMap.put(entry.getKey(), entry); entryMap.put(fakeEntry.getKey(), fakeEntry); batteryHistoryMap.put(batteryHistoryKeys[4], entryMap); @@ -619,33 +646,54 @@ public class DataProcessorTest { assertBatteryDiffEntry( resultDiffData.getAppDiffEntryList().get(0), currentUserId, /*uid=*/ 2L, 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( resultDiffData.getAppDiffEntryList().get(1), currentUserId, /*uid=*/ 4L, 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( resultDiffData.getSystemDiffEntryList().get(0), currentUserId, /*uid=*/ 3L, 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); assertBatteryDiffEntry( resultDiffData.getAppDiffEntryList().get(0), currentUserId, /*uid=*/ 2L, 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); assertBatteryDiffEntry( resultDiffData.getAppDiffEntryList().get(0), currentUserId, /*uid=*/ 4L, 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( resultDiffData.getAppDiffEntryList().get(1), currentUserId, /*uid=*/ 2L, 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( resultDiffData.getSystemDiffEntryList().get(0), currentUserId, /*uid=*/ 3L, 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) .action(mContext.getApplicationContext(), SettingsEnums.ACTION_BATTERY_USAGE_SHOWN_APP_COUNT, @@ -668,55 +716,82 @@ public class DataProcessorTest { // Adds the index = 0 data. Map entryMap = new HashMap<>(); 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, - /*backgroundUsageTimeInMs=*/ 20L); + /*foregroundServiceUsageTimeInMs=*/ 10L, /*backgroundUsageTimeInMs=*/ 20L); entryMap.put(entry.getKey(), entry); 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, - /*backgroundUsageTimeInMs=*/ 20L); + /*foregroundServiceUsageTimeInMs=*/ 10L, /*backgroundUsageTimeInMs=*/ 20L); entryMap.put(entry.getKey(), entry); 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, - /*backgroundUsageTimeInMs=*/ 30L); + /*foregroundServiceUsageTimeInMs=*/ 20L, /*backgroundUsageTimeInMs=*/ 30L); entryMap.put(entry.getKey(), entry); batteryHistoryMap.put(batteryHistoryKeys[0], entryMap); // Adds the index = 1 data. entryMap = new HashMap<>(); 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, - /*backgroundUsageTimeInMs=*/ 30L); + /*foregroundServiceUsageTimeInMs=*/ 20L, /*backgroundUsageTimeInMs=*/ 30L); entryMap.put(entry.getKey(), entry); 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, - /*backgroundUsageTimeInMs=*/ 20L); + /*foregroundServiceUsageTimeInMs=*/ 10L, /*backgroundUsageTimeInMs=*/ 20L); entryMap.put(entry.getKey(), entry); 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, - /*backgroundUsageTimeInMs=*/ 30L); + /*foregroundServiceUsageTimeInMs=*/ 30L, /*backgroundUsageTimeInMs=*/ 30L); entryMap.put(entry.getKey(), entry); batteryHistoryMap.put(batteryHistoryKeys[1], entryMap); // Adds the index = 2 data. entryMap = new HashMap<>(); 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, - /*backgroundUsageTimeInMs=*/ 30L); + /*foregroundServiceUsageTimeInMs=*/ 25L, /*backgroundUsageTimeInMs=*/ 30L); entryMap.put(entry.getKey(), entry); 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, - /*backgroundUsageTimeInMs=*/ 20L); + /*foregroundServiceUsageTimeInMs=*/ 25L, /*backgroundUsageTimeInMs=*/ 20L); entryMap.put(entry.getKey(), entry); 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, - /*backgroundUsageTimeInMs=*/ 30L); + /*foregroundServiceUsageTimeInMs=*/ 35L, /*backgroundUsageTimeInMs=*/ 30L); entryMap.put(entry.getKey(), entry); batteryHistoryMap.put(batteryHistoryKeys[2], entryMap); final List hourlyBatteryLevelsPerDay = @@ -737,11 +812,17 @@ public class DataProcessorTest { assertBatteryDiffEntry( resultDiffData.getAppDiffEntryList().get(0), currentUserId, /*uid=*/ 1L, 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( resultDiffData.getSystemDiffEntryList().get(0), BatteryUtils.UID_OTHER_USERS, /*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); assertThat(resultMap.get(0).get(0)).isNotNull(); assertThat(resultMap.get(0).get(DataProcessor.SELECTED_INDEX_ALL)).isNotNull(); @@ -767,24 +848,34 @@ public class DataProcessorTest { // Adds the index = 0 data. Map entryMap = new HashMap<>(); 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, - /*backgroundUsageTimeInMs=*/ 0L); + /*foregroundServiceUsageTimeInMs=*/ 0L, /*backgroundUsageTimeInMs=*/ 0L); entryMap.put(entry.getKey(), entry); batteryHistoryMap.put(batteryHistoryKeys[0], entryMap); // Adds the index = 1 data. entryMap = new HashMap<>(); 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, - /*backgroundUsageTimeInMs=*/ 0L); + /*foregroundServiceUsageTimeInMs=*/ 0L, /*backgroundUsageTimeInMs=*/ 0L); entryMap.put(entry.getKey(), entry); batteryHistoryMap.put(batteryHistoryKeys[1], entryMap); // Adds the index = 2 data. entryMap = new HashMap<>(); 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, + /*foregroundServiceUsageTimeInMs=*/ 1800000L, /*backgroundUsageTimeInMs=*/ 7200000L); entryMap.put(entry.getKey(), entry); batteryHistoryMap.put(batteryHistoryKeys[2], entryMap); @@ -808,10 +899,20 @@ public class DataProcessorTest { final BatteryDiffEntry resultEntry = resultDiffData.getAppDiffEntryList().get(0); assertThat(resultEntry.mForegroundUsageTimeInMs) .isEqualTo(Math.round(entry.mForegroundUsageTimeInMs * ratio)); + assertThat(resultEntry.mForegroundServiceUsageTimeInMs) + .isEqualTo(Math.round(entry.mForegroundServiceUsageTimeInMs * ratio)); assertThat(resultEntry.mBackgroundUsageTimeInMs) .isEqualTo(Math.round(entry.mBackgroundUsageTimeInMs * ratio)); assertThat(resultEntry.mConsumePower) .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(DataProcessor.SELECTED_INDEX_ALL)).isNotNull(); verify(mMetricsFeatureProvider) @@ -836,40 +937,58 @@ public class DataProcessorTest { // Adds the index = 0 data. Map entryMap = new HashMap<>(); 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, - /*backgroundUsageTimeInMs=*/ 0L); + /*foregroundServiceUsageTimeInMs=*/ 0L, /*backgroundUsageTimeInMs=*/ 0L); entryMap.put(entry.getKey(), entry); 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, - /*backgroundUsageTimeInMs=*/ 0L); + /*foregroundServiceUsageTimeInMs=*/ 0L, /*backgroundUsageTimeInMs=*/ 0L); entryMap.put(entry.getKey(), entry); batteryHistoryMap.put(batteryHistoryKeys[0], entryMap); // Adds the index = 1 data. entryMap = new HashMap<>(); 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, - /*backgroundUsageTimeInMs=*/ 0L); + /*foregroundServiceUsageTimeInMs=*/ 0L, /*backgroundUsageTimeInMs=*/ 0L); entryMap.put(entry.getKey(), entry); 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, - /*backgroundUsageTimeInMs=*/ 0L); + /*foregroundServiceUsageTimeInMs=*/ 0L, /*backgroundUsageTimeInMs=*/ 0L); entryMap.put(entry.getKey(), entry); batteryHistoryMap.put(batteryHistoryKeys[1], entryMap); // Adds the index = 2 data. entryMap = new HashMap<>(); 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, - /*backgroundUsageTimeInMs=*/ 20L); + /*foregroundServiceUsageTimeInMs=*/ 15L, /*backgroundUsageTimeInMs=*/ 20L); entryMap.put(entry.getKey(), entry); 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, - /*backgroundUsageTimeInMs=*/ 20L); + /*foregroundServiceUsageTimeInMs=*/ 15L, /*backgroundUsageTimeInMs=*/ 20L); entryMap.put(entry.getKey(), entry); batteryHistoryMap.put(batteryHistoryKeys[2], entryMap); final List hourlyBatteryLevelsPerDay = @@ -892,7 +1011,10 @@ public class DataProcessorTest { assertBatteryDiffEntry( resultDiffData.getAppDiffEntryList().get(0), currentUserId, /*uid=*/ 2L, 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) .action(mContext.getApplicationContext(), SettingsEnums.ACTION_BATTERY_USAGE_SHOWN_APP_COUNT, @@ -915,40 +1037,58 @@ public class DataProcessorTest { // Adds the index = 0 data. Map entryMap = new HashMap<>(); 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, - /*backgroundUsageTimeInMs=*/ 0L); + /*foregroundServiceUsageTimeInMs=*/ 0L, /*backgroundUsageTimeInMs=*/ 0L); entryMap.put(entry.getKey(), entry); 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, - /*backgroundUsageTimeInMs=*/ 0L); + /*foregroundServiceUsageTimeInMs=*/ 0L, /*backgroundUsageTimeInMs=*/ 0L); entryMap.put(entry.getKey(), entry); batteryHistoryMap.put(batteryHistoryKeys[0], entryMap); // Adds the index = 1 data. entryMap = new HashMap<>(); 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, - /*backgroundUsageTimeInMs=*/ 0L); + /*foregroundServiceUsageTimeInMs=*/ 0L, /*backgroundUsageTimeInMs=*/ 0L); entryMap.put(entry.getKey(), entry); 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, - /*backgroundUsageTimeInMs=*/ 0L); + /*foregroundServiceUsageTimeInMs=*/ 0L, /*backgroundUsageTimeInMs=*/ 0L); entryMap.put(entry.getKey(), entry); batteryHistoryMap.put(batteryHistoryKeys[1], entryMap); // Adds the index = 2 data. entryMap = new HashMap<>(); 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, - /*backgroundUsageTimeInMs=*/ 20L); + /*foregroundServiceUsageTimeInMs=*/ 15L, /*backgroundUsageTimeInMs=*/ 20L); entryMap.put(entry.getKey(), entry); 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, - /*backgroundUsageTimeInMs=*/ 20L); + /*foregroundServiceUsageTimeInMs=*/ 15L, /*backgroundUsageTimeInMs=*/ 20L); entryMap.put(entry.getKey(), entry); batteryHistoryMap.put(batteryHistoryKeys[2], entryMap); final List hourlyBatteryLevelsPerDay = @@ -996,22 +1136,42 @@ public class DataProcessorTest { batteryEntryList.add(mMockBatteryEntry3); batteryEntryList.add(mMockBatteryEntry4); 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(20L).when(mMockBatteryEntry1).getTimeInForegroundServiceMs(); doReturn(40L).when(mMockBatteryEntry1).getTimeInBackgroundMs(); doReturn(1).when(mMockBatteryEntry1).getUid(); doReturn(ConvertUtils.CONSUMER_TYPE_UID_BATTERY).when(mMockBatteryEntry1).getConsumerType(); 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(30L).when(mMockBatteryEntry2).getTimeInForegroundServiceMs(); doReturn(20L).when(mMockBatteryEntry2).getTimeInBackgroundMs(); doReturn(2).when(mMockBatteryEntry2).getUid(); doReturn(ConvertUtils.CONSUMER_TYPE_UID_BATTERY).when(mMockBatteryEntry2).getConsumerType(); 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).getTimeInForegroundServiceMs(); doReturn(0L).when(mMockBatteryEntry3).getTimeInBackgroundMs(); doReturn(3).when(mMockBatteryEntry3).getUid(); doReturn(ConvertUtils.CONSUMER_TYPE_UID_BATTERY).when(mMockBatteryEntry3).getConsumerType(); 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(15L).when(mMockBatteryEntry4).getTimeInForegroundServiceMs(); doReturn(10L).when(mMockBatteryEntry4).getTimeInBackgroundMs(); doReturn(4).when(mMockBatteryEntry4).getUid(); doReturn(ConvertUtils.CONSUMER_TYPE_SYSTEM_BATTERY) @@ -1025,15 +1185,24 @@ public class DataProcessorTest { assertBatteryDiffEntry( batteryDiffData.getAppDiffEntryList().get(0), 0, /*uid=*/ 2L, 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( batteryDiffData.getAppDiffEntryList().get(1), 0, /*uid=*/ 1L, 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( batteryDiffData.getSystemDiffEntryList().get(0), 0, /*uid=*/ 4L, 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> createHistoryMap( @@ -1068,15 +1237,24 @@ public class DataProcessorTest { private static BatteryHistEntry createBatteryHistEntry( 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 foregroundUsageTimeInMs, final long backgroundUsageTimeInMs) { + final long foregroundUsageTimeInMs, final long foregroundServiceUsageTimeInMs, + final long backgroundUsageTimeInMs) { // Only insert required fields. final BatteryInformation batteryInformation = BatteryInformation .newBuilder() .setAppLabel(appLabel) .setConsumePower(consumePower) + .setForegroundUsageConsumePower(foregroundUsageConsumePower) + .setForegroundServiceUsageConsumePower(foregroundServiceUsageConsumePower) + .setBackgroundUsageConsumePower(backgroundUsageConsumePower) + .setCachedUsageConsumePower(cachedUsageConsumePower) .setForegroundUsageTimeInMs(foregroundUsageTimeInMs) + .setForegroundServiceUsageTimeInMs(foregroundServiceUsageTimeInMs) .setBackgroundUsageTimeInMs(backgroundUsageTimeInMs) .build(); final ContentValues values = new ContentValues(); @@ -1152,12 +1330,23 @@ public class DataProcessorTest { private static void assertBatteryDiffEntry( final BatteryDiffEntry entry, final long userId, final long uid, 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.mUid).isEqualTo(uid); assertThat(entry.mBatteryHistEntry.mConsumerType).isEqualTo(consumerType); 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.mForegroundServiceUsageTimeInMs) + .isEqualTo(foregroundServiceUsageTimeInMs); assertThat(entry.mBackgroundUsageTimeInMs).isEqualTo(backgroundUsageTimeInMs); } } diff --git a/tests/robotests/src/com/android/settings/fuelgauge/batteryusage/db/BatteryStateTest.java b/tests/robotests/src/com/android/settings/fuelgauge/batteryusage/db/BatteryStateTest.java index 5482065a686..002e4fd1df4 100644 --- a/tests/robotests/src/com/android/settings/fuelgauge/batteryusage/db/BatteryStateTest.java +++ b/tests/robotests/src/com/android/settings/fuelgauge/batteryusage/db/BatteryStateTest.java @@ -56,9 +56,14 @@ public final class BatteryStateTest { .setAppLabel("Settings") .setTotalPower(100) .setConsumePower(3) + .setForegroundUsageConsumePower(0) + .setForegroundServiceUsageConsumePower(1) + .setBackgroundUsageConsumePower(2) + .setCachedUsageConsumePower(3) .setPercentOfTotal(10) .setDrainType(1) .setForegroundUsageTimeInMs(60000) + .setForegroundServiceUsageTimeInMs(30000) .setBackgroundUsageTimeInMs(10000) .build(); }