diff --git a/src/com/android/settings/fuelgauge/AdvancedPowerUsageDetail.java b/src/com/android/settings/fuelgauge/AdvancedPowerUsageDetail.java index 86ef3cf4649..23680d9bf66 100644 --- a/src/com/android/settings/fuelgauge/AdvancedPowerUsageDetail.java +++ b/src/com/android/settings/fuelgauge/AdvancedPowerUsageDetail.java @@ -148,7 +148,8 @@ public class AdvancedPowerUsageDetail extends DashboardFragment launchArgs.mShowTimeInformation = showTimeInformation; if (launchArgs.mShowTimeInformation) { launchArgs.mForegroundTimeMs = diffEntry.mForegroundUsageTimeInMs; - launchArgs.mBackgroundTimeMs = diffEntry.mBackgroundUsageTimeInMs; + launchArgs.mBackgroundTimeMs = + diffEntry.mBackgroundUsageTimeInMs + diffEntry.mForegroundServiceUsageTimeInMs; launchArgs.mScreenOnTimeMs = diffEntry.mScreenOnTimeInMs; launchArgs.mAnomalyHintPrefKey = anomalyHintPrefKey; launchArgs.mAnomalyHintText = anomalyHintText; diff --git a/src/com/android/settings/fuelgauge/batteryusage/BatteryDiffEntry.java b/src/com/android/settings/fuelgauge/batteryusage/BatteryDiffEntry.java index bad1b76de50..2c376e5fcec 100644 --- a/src/com/android/settings/fuelgauge/batteryusage/BatteryDiffEntry.java +++ b/src/com/android/settings/fuelgauge/batteryusage/BatteryDiffEntry.java @@ -92,6 +92,7 @@ public class BatteryDiffEntry { public String mLegacyLabel; public int mConsumerType; public long mForegroundUsageTimeInMs; + public long mForegroundServiceUsageTimeInMs; public long mBackgroundUsageTimeInMs; public long mScreenOnTimeInMs; public double mConsumePower; @@ -125,6 +126,7 @@ public class BatteryDiffEntry { String legacyLabel, int consumerType, long foregroundUsageTimeInMs, + long foregroundServiceUsageTimeInMs, long backgroundUsageTimeInMs, long screenOnTimeInMs, double consumePower, @@ -142,6 +144,7 @@ public class BatteryDiffEntry { mLegacyLabel = legacyLabel; mConsumerType = consumerType; mForegroundUsageTimeInMs = foregroundUsageTimeInMs; + mForegroundServiceUsageTimeInMs = foregroundServiceUsageTimeInMs; mBackgroundUsageTimeInMs = backgroundUsageTimeInMs; mScreenOnTimeInMs = screenOnTimeInMs; mConsumePower = consumePower; @@ -164,6 +167,7 @@ public class BatteryDiffEntry { legacyLabel, consumerType, /* foregroundUsageTimeInMs= */ 0, + /* foregroundServiceUsageTimeInMs= */ 0, /* backgroundUsageTimeInMs= */ 0, /* screenOnTimeInMs= */ 0, /* consumePower= */ 0, @@ -232,6 +236,7 @@ public class BatteryDiffEntry { this.mLegacyLabel, this.mConsumerType, this.mForegroundUsageTimeInMs, + this.mForegroundServiceUsageTimeInMs, this.mBackgroundUsageTimeInMs, this.mScreenOnTimeInMs, this.mConsumePower, @@ -515,48 +520,50 @@ public class BatteryDiffEntry { @Override public String toString() { - final StringBuilder builder = - new StringBuilder() - .append("BatteryDiffEntry{") - .append( - String.format( - "\n\tname=%s restrictable=%b", - mAppLabel, mValidForRestriction)) - .append( - String.format( - "\n\tconsume=%.2f%% %f/%f", - mPercentage, mConsumePower, mTotalConsumePower)) - .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 background:%s screen-on:%s", - StringUtil.formatElapsedTime( - mContext, - (double) mForegroundUsageTimeInMs, - /* withSeconds= */ true, - /* collapseTimeUnit= */ false), - StringUtil.formatElapsedTime( - mContext, - (double) mBackgroundUsageTimeInMs, - /* withSeconds= */ true, - /* collapseTimeUnit= */ false), - StringUtil.formatElapsedTime( - mContext, - (double) mScreenOnTimeInMs, - /* withSeconds= */ true, - /* collapseTimeUnit= */ false))) - .append( - String.format( - "\n\tpackage:%s|%s uid:%d userId:%d", - mLegacyPackageName, getPackageName(), mUid, mUserId)); + final StringBuilder builder = new StringBuilder(); + builder.append("BatteryDiffEntry{"); + builder.append( + String.format("\n\tname=%s restrictable=%b", mAppLabel, mValidForRestriction)); + builder.append( + String.format( + "\n\tconsume=%.2f%% %f/%f", + mPercentage, mConsumePower, mTotalConsumePower)); + builder.append( + String.format( + "\n\tconsume power= foreground:%f foregroundService:%f", + mForegroundUsageConsumePower, mForegroundServiceUsageConsumePower)); + builder.append( + String.format( + "\n\tconsume power= background:%f cached:%f", + mBackgroundUsageConsumePower, mCachedUsageConsumePower)); + builder.append( + String.format( + "\n\ttime= foreground:%s foregroundService:%s " + + "background:%s screen-on:%s", + StringUtil.formatElapsedTime( + mContext, + (double) mForegroundUsageTimeInMs, + /* withSeconds= */ true, + /* collapseTimeUnit= */ false), + StringUtil.formatElapsedTime( + mContext, + (double) mForegroundServiceUsageTimeInMs, + /* withSeconds= */ true, + /* collapseTimeUnit= */ false), + StringUtil.formatElapsedTime( + mContext, + (double) mBackgroundUsageTimeInMs, + /* withSeconds= */ true, + /* collapseTimeUnit= */ false), + StringUtil.formatElapsedTime( + mContext, + (double) mScreenOnTimeInMs, + /* withSeconds= */ true, + /* collapseTimeUnit= */ false))); + builder.append( + String.format( + "\n\tpackage:%s|%s uid:%d userId:%d", + mLegacyPackageName, getPackageName(), mUid, mUserId)); return builder.toString(); } diff --git a/src/com/android/settings/fuelgauge/batteryusage/BatteryEntry.java b/src/com/android/settings/fuelgauge/batteryusage/BatteryEntry.java index 751e7ad0665..4b65cc9c116 100644 --- a/src/com/android/settings/fuelgauge/batteryusage/BatteryEntry.java +++ b/src/com/android/settings/fuelgauge/batteryusage/BatteryEntry.java @@ -111,6 +111,7 @@ public class BatteryEntry { @BatteryConsumer.PowerComponent private final int mPowerComponentId; private long mUsageDurationMs; private long mTimeInForegroundMs; + private long mTimeInForegroundServiceMs; private long mTimeInBackgroundMs; public String mName; @@ -188,9 +189,14 @@ public class BatteryEntry { } } mTimeInForegroundMs = - uidBatteryConsumer.getTimeInStateMs(UidBatteryConsumer.STATE_FOREGROUND); + uidBatteryConsumer.getTimeInProcessStateMs( + UidBatteryConsumer.PROCESS_STATE_FOREGROUND); + mTimeInForegroundServiceMs = + uidBatteryConsumer.getTimeInProcessStateMs( + UidBatteryConsumer.PROCESS_STATE_FOREGROUND_SERVICE); mTimeInBackgroundMs = - uidBatteryConsumer.getTimeInStateMs(UidBatteryConsumer.STATE_BACKGROUND); + uidBatteryConsumer.getTimeInProcessStateMs( + UidBatteryConsumer.PROCESS_STATE_BACKGROUND); mConsumedPowerInForeground = safeGetConsumedPower( uidBatteryConsumer, BATTERY_DIMENSIONS[BATTERY_USAGE_INDEX_FOREGROUND]); @@ -433,20 +439,19 @@ public class BatteryEntry { /** Returns foreground time/ms that is attributed to this entry. */ public long getTimeInForegroundMs() { - if (mBatteryConsumer instanceof UidBatteryConsumer) { - return mTimeInForegroundMs; - } else { - return mUsageDurationMs; - } + return (mBatteryConsumer instanceof UidBatteryConsumer) + ? mTimeInForegroundMs + : mUsageDurationMs; + } + + /** Returns foreground service time/ms that is attributed to this entry. */ + public long getTimeInForegroundServiceMs() { + return (mBatteryConsumer instanceof UidBatteryConsumer) ? mTimeInForegroundServiceMs : 0; } /** Returns background activity time/ms that is attributed to this entry. */ public long getTimeInBackgroundMs() { - if (mBatteryConsumer instanceof UidBatteryConsumer) { - return mTimeInBackgroundMs; - } else { - return 0; - } + return (mBatteryConsumer instanceof UidBatteryConsumer) ? mTimeInBackgroundMs : 0; } /** Returns total amount of power (in milli-amp-hours) that is attributed to this entry. */ @@ -510,9 +515,14 @@ public class BatteryEntry { if (batteryConsumer instanceof UidBatteryConsumer) { UidBatteryConsumer uidBatteryConsumer = (UidBatteryConsumer) batteryConsumer; mTimeInForegroundMs += - uidBatteryConsumer.getTimeInStateMs(UidBatteryConsumer.STATE_FOREGROUND); + uidBatteryConsumer.getTimeInProcessStateMs( + UidBatteryConsumer.PROCESS_STATE_FOREGROUND); + mTimeInForegroundServiceMs += + uidBatteryConsumer.getTimeInProcessStateMs( + UidBatteryConsumer.PROCESS_STATE_FOREGROUND_SERVICE); mTimeInBackgroundMs += - uidBatteryConsumer.getTimeInStateMs(UidBatteryConsumer.STATE_BACKGROUND); + uidBatteryConsumer.getTimeInProcessStateMs( + UidBatteryConsumer.PROCESS_STATE_BACKGROUND); mConsumedPowerInForeground += safeGetConsumedPower( uidBatteryConsumer, BATTERY_DIMENSIONS[BATTERY_USAGE_INDEX_FOREGROUND]); diff --git a/src/com/android/settings/fuelgauge/batteryusage/BatteryHistEntry.java b/src/com/android/settings/fuelgauge/batteryusage/BatteryHistEntry.java index 97cdc34030d..b42d3733f00 100644 --- a/src/com/android/settings/fuelgauge/batteryusage/BatteryHistEntry.java +++ b/src/com/android/settings/fuelgauge/batteryusage/BatteryHistEntry.java @@ -20,8 +20,6 @@ import android.database.Cursor; import android.os.BatteryConsumer; import android.util.Log; -import java.time.Duration; - /** A container class to carry data from {@link ContentValues}. */ public class BatteryHistEntry { private static final boolean DEBUG = false; @@ -57,6 +55,7 @@ public class BatteryHistEntry { 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; @ConvertUtils.ConsumerType public final int mConsumerType; @@ -89,6 +88,7 @@ public class BatteryHistEntry { mCachedUsageConsumePower = batteryInformation.getCachedUsageConsumePower(); mPercentOfTotal = batteryInformation.getPercentOfTotal(); mForegroundUsageTimeInMs = batteryInformation.getForegroundUsageTimeInMs(); + mForegroundServiceUsageTimeInMs = batteryInformation.getForegroundServiceUsageTimeInMs(); mBackgroundUsageTimeInMs = batteryInformation.getBackgroundUsageTimeInMs(); mDrainType = batteryInformation.getDrainType(); final DeviceBatteryState deviceBatteryState = batteryInformation.getDeviceBatteryState(); @@ -118,6 +118,7 @@ public class BatteryHistEntry { mCachedUsageConsumePower = batteryInformation.getCachedUsageConsumePower(); mPercentOfTotal = batteryInformation.getPercentOfTotal(); mForegroundUsageTimeInMs = batteryInformation.getForegroundUsageTimeInMs(); + mForegroundServiceUsageTimeInMs = batteryInformation.getForegroundServiceUsageTimeInMs(); mBackgroundUsageTimeInMs = batteryInformation.getBackgroundUsageTimeInMs(); mDrainType = batteryInformation.getDrainType(); final DeviceBatteryState deviceBatteryState = batteryInformation.getDeviceBatteryState(); @@ -137,6 +138,7 @@ public class BatteryHistEntry { double backgroundUsageConsumePower, double cachedUsageConsumePower, long foregroundUsageTimeInMs, + long foregroundServiceUsageTimeInMs, long backgroundUsageTimeInMs, int batteryLevel) { mUid = fromEntry.mUid; @@ -155,6 +157,7 @@ public class BatteryHistEntry { mCachedUsageConsumePower = cachedUsageConsumePower; mPercentOfTotal = fromEntry.mPercentOfTotal; mForegroundUsageTimeInMs = foregroundUsageTimeInMs; + mForegroundServiceUsageTimeInMs = foregroundServiceUsageTimeInMs; mBackgroundUsageTimeInMs = backgroundUsageTimeInMs; mDrainType = fromEntry.mDrainType; mConsumerType = fromEntry.mConsumerType; @@ -189,45 +192,40 @@ public class BatteryHistEntry { @Override public String toString() { final String recordAtDateTime = ConvertUtils.utcToLocalTimeForLogging(mTimestamp); - final StringBuilder builder = - new StringBuilder() - .append("\nBatteryHistEntry{") - .append( - String.format( - "\n\tpackage=%s|label=%s|uid=%d|userId=%d|isHidden=%b", - 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", - 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", - Duration.ofMillis(mForegroundUsageTimeInMs).getSeconds(), - Duration.ofMillis(mBackgroundUsageTimeInMs).getSeconds())) - .append( - String.format( - "\n\tdrainType=%d|consumerType=%d", - mDrainType, mConsumerType)) - .append( - String.format( - "\n\tbattery=%d|status=%d|health=%d\n}", - mBatteryLevel, mBatteryStatus, mBatteryHealth)); + final StringBuilder builder = new StringBuilder(); + builder.append("\nBatteryHistEntry{"); + builder.append( + String.format( + "\n\tpackage=%s|label=%s|uid=%d|userId=%d|isHidden=%b", + mPackageName, mAppLabel, mUid, mUserId, mIsHidden)); + builder.append( + String.format( + "\n\ttimestamp=%s|zoneId=%s|bootTimestamp=%d", + recordAtDateTime, mZoneId, TimestampUtils.getSeconds(mBootTimestamp))); + builder.append( + String.format( + "\n\tusage=%f|total=%f|consume=%f", + mPercentOfTotal, mTotalPower, mConsumePower)); + builder.append( + String.format( + "\n\tforeground=%f|foregroundService=%f", + mForegroundUsageConsumePower, mForegroundServiceUsageConsumePower)); + builder.append( + String.format( + "\n\tbackground=%f|cached=%f", + mBackgroundUsageConsumePower, mCachedUsageConsumePower)); + builder.append( + String.format( + "\n\telapsedTime,fg=%d|fgs=%d|bg=%d", + TimestampUtils.getSeconds(mBackgroundUsageTimeInMs), + TimestampUtils.getSeconds(mForegroundServiceUsageTimeInMs), + TimestampUtils.getSeconds(mBackgroundUsageTimeInMs))); + builder.append( + String.format("\n\tdrainType=%d|consumerType=%d", mDrainType, mConsumerType)); + builder.append( + String.format( + "\n\tbattery=%d|status=%d|health=%d\n}", + mBatteryLevel, mBatteryStatus, mBatteryHealth)); return builder.toString(); } @@ -323,19 +321,20 @@ public class BatteryHistEntry { ratio); final double foregroundUsageTimeInMs = interpolate( - (double) - (lowerHistEntry == null - ? 0 - : lowerHistEntry.mForegroundUsageTimeInMs), - (double) upperHistEntry.mForegroundUsageTimeInMs, + (lowerHistEntry == null ? 0 : lowerHistEntry.mForegroundUsageTimeInMs), + upperHistEntry.mForegroundUsageTimeInMs, + ratio); + final double foregroundServiceUsageTimeInMs = + interpolate( + (lowerHistEntry == null + ? 0 + : lowerHistEntry.mForegroundServiceUsageTimeInMs), + upperHistEntry.mForegroundServiceUsageTimeInMs, ratio); final double backgroundUsageTimeInMs = interpolate( - (double) - (lowerHistEntry == null - ? 0 - : lowerHistEntry.mBackgroundUsageTimeInMs), - (double) upperHistEntry.mBackgroundUsageTimeInMs, + (lowerHistEntry == null ? 0 : lowerHistEntry.mBackgroundUsageTimeInMs), + upperHistEntry.mBackgroundUsageTimeInMs, ratio); // Checks whether there is any abnormal cases! if (upperHistEntry.mConsumePower < consumePower @@ -345,6 +344,7 @@ public class BatteryHistEntry { || upperHistEntry.mBackgroundUsageConsumePower < backgroundUsageConsumePower || upperHistEntry.mCachedUsageConsumePower < cachedUsageConsumePower || upperHistEntry.mForegroundUsageTimeInMs < foregroundUsageTimeInMs + || upperHistEntry.mForegroundServiceUsageTimeInMs < foregroundServiceUsageTimeInMs || upperHistEntry.mBackgroundUsageTimeInMs < backgroundUsageTimeInMs) { if (DEBUG) { Log.w( @@ -371,6 +371,7 @@ public class BatteryHistEntry { backgroundUsageConsumePower, cachedUsageConsumePower, Math.round(foregroundUsageTimeInMs), + Math.round(foregroundServiceUsageTimeInMs), Math.round(backgroundUsageTimeInMs), (int) Math.round(batteryLevel)); } diff --git a/src/com/android/settings/fuelgauge/batteryusage/BatteryUsageBreakdownController.java b/src/com/android/settings/fuelgauge/batteryusage/BatteryUsageBreakdownController.java index d6f8709f590..0ffd0903b78 100644 --- a/src/com/android/settings/fuelgauge/batteryusage/BatteryUsageBreakdownController.java +++ b/src/com/android/settings/fuelgauge/batteryusage/BatteryUsageBreakdownController.java @@ -400,7 +400,7 @@ public class BatteryUsageBreakdownController extends BasePreferenceController mPrefContext, entry.isSystemEntry(), entry.mForegroundUsageTimeInMs, - entry.mBackgroundUsageTimeInMs, + entry.mBackgroundUsageTimeInMs + entry.mForegroundServiceUsageTimeInMs, entry.mScreenOnTimeInMs)); } } diff --git a/src/com/android/settings/fuelgauge/batteryusage/ConvertUtils.java b/src/com/android/settings/fuelgauge/batteryusage/ConvertUtils.java index ae93734cc6a..e23e2190a18 100644 --- a/src/com/android/settings/fuelgauge/batteryusage/ConvertUtils.java +++ b/src/com/android/settings/fuelgauge/batteryusage/ConvertUtils.java @@ -544,6 +544,7 @@ public final class ConvertUtils { batteryUsageDiff.getLabel(), batteryUsageDiff.getConsumerType(), batteryUsageDiff.getForegroundUsageTime(), + batteryUsageDiff.getForegroundServiceUsageTime(), batteryUsageDiff.getBackgroundUsageTime(), batteryUsageDiff.getScreenOnTime(), batteryUsageDiff.getConsumePower(), @@ -612,6 +613,7 @@ public final class ConvertUtils { .setPercentOfTotal(entry.mPercent) .setDrainType(entry.getPowerComponentId()) .setForegroundUsageTimeInMs(entry.getTimeInForegroundMs()) + .setForegroundServiceUsageTimeInMs(entry.getTimeInForegroundServiceMs()) .setBackgroundUsageTimeInMs(entry.getTimeInBackgroundMs()); } diff --git a/src/com/android/settings/fuelgauge/batteryusage/DataProcessor.java b/src/com/android/settings/fuelgauge/batteryusage/DataProcessor.java index d8f0a770070..2ef12f18007 100644 --- a/src/com/android/settings/fuelgauge/batteryusage/DataProcessor.java +++ b/src/com/android/settings/fuelgauge/batteryusage/DataProcessor.java @@ -675,6 +675,7 @@ public final class DataProcessor { entry.mAppLabel, entry.mConsumerType, entry.mForegroundUsageTimeInMs, + entry.mForegroundServiceUsageTimeInMs, entry.mBackgroundUsageTimeInMs, /* screenOnTimeInMs= */ 0, entry.mConsumePower, @@ -1412,6 +1413,7 @@ public final class DataProcessor { // Cumulative values is a specific time slot for a specific app. long foregroundUsageTimeInMs = 0; + long foregroundServiceUsageTimeInMs = 0; long backgroundUsageTimeInMs = 0; double consumePower = 0; double foregroundUsageConsumePower = 0; @@ -1425,6 +1427,10 @@ public final class DataProcessor { getDiffValue( currentEntry.mForegroundUsageTimeInMs, nextEntry.mForegroundUsageTimeInMs); + foregroundServiceUsageTimeInMs += + getDiffValue( + currentEntry.mForegroundServiceUsageTimeInMs, + nextEntry.mForegroundServiceUsageTimeInMs); backgroundUsageTimeInMs += getDiffValue( currentEntry.mBackgroundUsageTimeInMs, @@ -1453,24 +1459,32 @@ public final class DataProcessor { foregroundUsageTimeInMs = slotScreenOnTime; } // Excludes entry since we don't have enough data to calculate. - if (foregroundUsageTimeInMs == 0 && backgroundUsageTimeInMs == 0 && consumePower == 0) { + if (foregroundUsageTimeInMs == 0 + && foregroundServiceUsageTimeInMs == 0 + && backgroundUsageTimeInMs == 0 + && consumePower == 0) { continue; } // Forces refine the cumulative value since it may introduce deviation error since we // will apply the interpolation arithmetic. - final float totalUsageTimeInMs = foregroundUsageTimeInMs + backgroundUsageTimeInMs; + final float totalUsageTimeInMs = + foregroundUsageTimeInMs + + backgroundUsageTimeInMs + + foregroundServiceUsageTimeInMs; if (totalUsageTimeInMs > slotDuration) { final float ratio = slotDuration / totalUsageTimeInMs; if (sDebug) { Log.w( TAG, String.format( - "abnormal usage time %d|%d for:\n%s", + "abnormal usage time %d|%d|%d for:\n%s", Duration.ofMillis(foregroundUsageTimeInMs).getSeconds(), + Duration.ofMillis(foregroundServiceUsageTimeInMs).getSeconds(), Duration.ofMillis(backgroundUsageTimeInMs).getSeconds(), selectedBatteryEntry)); } foregroundUsageTimeInMs = Math.round(foregroundUsageTimeInMs * ratio); + foregroundServiceUsageTimeInMs = Math.round(foregroundServiceUsageTimeInMs * ratio); backgroundUsageTimeInMs = Math.round(backgroundUsageTimeInMs * ratio); consumePower = consumePower * ratio; foregroundUsageConsumePower = foregroundUsageConsumePower * ratio; @@ -1487,9 +1501,14 @@ public final class DataProcessor { appUsageMap, selectedBatteryEntry.mUserId, selectedBatteryEntry.mPackageName)); - // Make sure the background + screen-on time will not exceed the threshold. + // Ensure the following value will not exceed the threshold. + // value = background + foregroundService + screen-on backgroundUsageTimeInMs = Math.min(backgroundUsageTimeInMs, (long) slotDuration - screenOnTime); + foregroundServiceUsageTimeInMs = + Math.min( + foregroundServiceUsageTimeInMs, + (long) slotDuration - screenOnTime - backgroundUsageTimeInMs); final BatteryDiffEntry currentBatteryDiffEntry = new BatteryDiffEntry( context, @@ -1502,6 +1521,7 @@ public final class DataProcessor { selectedBatteryEntry.mAppLabel, selectedBatteryEntry.mConsumerType, foregroundUsageTimeInMs, + foregroundServiceUsageTimeInMs, backgroundUsageTimeInMs, screenOnTime, consumePower, @@ -1647,6 +1667,8 @@ public final class DataProcessor { } else { // Sums up some field data into the existing one. oldBatteryDiffEntry.mForegroundUsageTimeInMs += entry.mForegroundUsageTimeInMs; + oldBatteryDiffEntry.mForegroundServiceUsageTimeInMs += + entry.mForegroundServiceUsageTimeInMs; oldBatteryDiffEntry.mBackgroundUsageTimeInMs += entry.mBackgroundUsageTimeInMs; oldBatteryDiffEntry.mScreenOnTimeInMs += entry.mScreenOnTimeInMs; oldBatteryDiffEntry.mConsumePower += entry.mConsumePower; diff --git a/src/com/android/settings/fuelgauge/batteryusage/DatabaseUtils.java b/src/com/android/settings/fuelgauge/batteryusage/DatabaseUtils.java index 7160da4290e..ee0e449a1e4 100644 --- a/src/com/android/settings/fuelgauge/batteryusage/DatabaseUtils.java +++ b/src/com/android/settings/fuelgauge/batteryusage/DatabaseUtils.java @@ -660,36 +660,39 @@ public final class DatabaseUtils { // Creates the ContentValues list to insert them into provider. final List valuesList = new ArrayList<>(); if (batteryEntryList != null) { - batteryEntryList.stream() - .filter( - entry -> { - final long foregroundMs = entry.getTimeInForegroundMs(); - final long backgroundMs = entry.getTimeInBackgroundMs(); - if (entry.getConsumedPower() == 0 - && (foregroundMs != 0 || backgroundMs != 0)) { - Log.w( - TAG, - String.format( - "no consumed power but has running time for %s" - + " time=%d|%d", - entry.getLabel(), foregroundMs, backgroundMs)); - } - return entry.getConsumedPower() != 0 - || foregroundMs != 0 - || backgroundMs != 0; - }) - .forEach( - entry -> - valuesList.add( - ConvertUtils.convertBatteryEntryToContentValues( - entry, - batteryUsageStats, - batteryLevel, - batteryStatus, - batteryHealth, - snapshotBootTimestamp, - snapshotTimestamp, - isFullChargeStart))); + for (BatteryEntry entry : batteryEntryList) { + final long foregroundMs = entry.getTimeInForegroundMs(); + final long foregroundServiceMs = entry.getTimeInForegroundServiceMs(); + final long backgroundMs = entry.getTimeInBackgroundMs(); + if (entry.getConsumedPower() == 0 + && (foregroundMs != 0 || foregroundServiceMs != 0 || backgroundMs != 0)) { + Log.w( + TAG, + String.format( + "no consumed power but has running time for %s" + + " time=%d|%d|%d", + entry.getLabel(), + foregroundMs, + foregroundServiceMs, + backgroundMs)); + } + if (entry.getConsumedPower() == 0 + && foregroundMs == 0 + && foregroundServiceMs == 0 + && backgroundMs == 0) { + continue; + } + valuesList.add( + ConvertUtils.convertBatteryEntryToContentValues( + entry, + batteryUsageStats, + batteryLevel, + batteryStatus, + batteryHealth, + snapshotBootTimestamp, + snapshotTimestamp, + isFullChargeStart)); + } } int size = 1; diff --git a/src/com/android/settings/fuelgauge/batteryusage/TimestampUtils.java b/src/com/android/settings/fuelgauge/batteryusage/TimestampUtils.java index 594a0effa80..41a2254f48f 100644 --- a/src/com/android/settings/fuelgauge/batteryusage/TimestampUtils.java +++ b/src/com/android/settings/fuelgauge/batteryusage/TimestampUtils.java @@ -16,6 +16,7 @@ package com.android.settings.fuelgauge.batteryusage; +import java.time.Duration; import java.util.Calendar; /** A utility class for timestamp operations. */ @@ -48,6 +49,10 @@ final class TimestampUtils { return calendar.getTimeInMillis(); } + static long getSeconds(final long timeInMs) { + return Duration.ofMillis(timeInMs).getSeconds(); + } + static boolean isMidnight(final long timestamp) { final Calendar calendar = Calendar.getInstance(); calendar.setTimeInMillis(timestamp); diff --git a/src/com/android/settings/fuelgauge/protos/battery_usage_slot.proto b/src/com/android/settings/fuelgauge/protos/battery_usage_slot.proto index 5bc1a3e330e..7f677707ded 100644 --- a/src/com/android/settings/fuelgauge/protos/battery_usage_slot.proto +++ b/src/com/android/settings/fuelgauge/protos/battery_usage_slot.proto @@ -31,4 +31,5 @@ message BatteryUsageDiff { optional int64 foreground_usage_time = 14; optional int64 background_usage_time = 15; optional int64 screen_on_time = 16; + optional int64 foreground_service_usage_time = 17; } diff --git a/src/com/android/settings/fuelgauge/protos/fuelgauge_usage_state.proto b/src/com/android/settings/fuelgauge/protos/fuelgauge_usage_state.proto index b9b05a3be73..d53b814069f 100644 --- a/src/com/android/settings/fuelgauge/protos/fuelgauge_usage_state.proto +++ b/src/com/android/settings/fuelgauge/protos/fuelgauge_usage_state.proto @@ -36,4 +36,5 @@ message BatteryInformation { optional double foreground_service_usage_consume_power = 17; optional double background_usage_consume_power = 18; optional double cached_usage_consume_power = 19; + optional int64 foreground_service_usage_time_in_ms = 20; } \ No newline at end of file diff --git a/tests/robotests/src/com/android/settings/fuelgauge/AdvancedPowerUsageDetailTest.java b/tests/robotests/src/com/android/settings/fuelgauge/AdvancedPowerUsageDetailTest.java index d01d7e02515..2f83da6f618 100644 --- a/tests/robotests/src/com/android/settings/fuelgauge/AdvancedPowerUsageDetailTest.java +++ b/tests/robotests/src/com/android/settings/fuelgauge/AdvancedPowerUsageDetailTest.java @@ -49,7 +49,9 @@ import androidx.loader.app.LoaderManager; import com.android.settings.R; import com.android.settings.SettingsActivity; +import com.android.settings.fuelgauge.batteryusage.BatteryDiffEntry; import com.android.settings.fuelgauge.batteryusage.BatteryEntry; +import com.android.settings.fuelgauge.batteryusage.ConvertUtils; import com.android.settings.testutils.FakeFeatureFactory; import com.android.settings.testutils.shadow.ShadowActivityManager; import com.android.settings.testutils.shadow.ShadowEntityHeaderController; @@ -91,11 +93,10 @@ public class AdvancedPowerUsageDetailTest { private static final String USAGE_PERCENT = "16%"; private static final int ICON_ID = 123; private static final int UID = 1; + private static final long FOREGROUND_TIME_MS = 444; + private static final long FOREGROUND_SERVICE_TIME_MS = 123; private static final long BACKGROUND_TIME_MS = 100; - private static final long FOREGROUND_ACTIVITY_TIME_MS = 123; - private static final long FOREGROUND_SERVICE_TIME_MS = 444; - private static final long FOREGROUND_TIME_MS = - FOREGROUND_ACTIVITY_TIME_MS + FOREGROUND_SERVICE_TIME_MS; + private static final long SCREEN_ON_TIME_MS = 321; private static final String KEY_ALLOW_BACKGROUND_USAGE = "allow_background_usage"; @Mock(answer = Answers.RETURNS_DEEP_STUBS) @@ -105,7 +106,6 @@ public class AdvancedPowerUsageDetailTest { @Mock private LayoutPreference mHeaderPreference; @Mock private ApplicationsState mState; @Mock private ApplicationsState.AppEntry mAppEntry; - @Mock private Bundle mBundle; @Mock private BatteryEntry mBatteryEntry; @Mock private PackageManager mPackageManager; @Mock private InstallSourceInfo mInstallSourceInfo; @@ -120,6 +120,8 @@ public class AdvancedPowerUsageDetailTest { private SettingsActivity mTestActivity; private FakeFeatureFactory mFeatureFactory; private MetricsFeatureProvider mMetricsFeatureProvider; + private BatteryDiffEntry mBatteryDiffEntry; + private Bundle mBundle; @Before public void setUp() { @@ -131,6 +133,7 @@ public class AdvancedPowerUsageDetailTest { mMetricsFeatureProvider = mFeatureFactory.metricsFeatureProvider; mFragment = spy(new AdvancedPowerUsageDetail()); + mBundle = spy(new Bundle()); doReturn(mContext).when(mFragment).getContext(); doReturn(mActivity).when(mFragment).getActivity(); doReturn(SUMMARY).when(mFragment).getString(anyInt()); @@ -163,10 +166,35 @@ public class AdvancedPowerUsageDetailTest { when(mBatteryEntry.getUid()).thenReturn(UID); when(mBatteryEntry.getLabel()).thenReturn(APP_LABEL); - when(mBatteryEntry.getTimeInBackgroundMs()).thenReturn(BACKGROUND_TIME_MS); when(mBatteryEntry.getTimeInForegroundMs()).thenReturn(FOREGROUND_TIME_MS); + when(mBatteryEntry.getTimeInForegroundServiceMs()).thenReturn(FOREGROUND_SERVICE_TIME_MS); + when(mBatteryEntry.getTimeInBackgroundMs()).thenReturn(BACKGROUND_TIME_MS); mBatteryEntry.mIconId = ICON_ID; + mBatteryDiffEntry = + spy( + new BatteryDiffEntry( + mContext, + /* uid= */ UID, + /* userId= */ 0, + /* key= */ "key", + /* isHidden= */ false, + /* componentId= */ -1, + /* legacyPackageName= */ null, + /* legacyLabel= */ null, + /*consumerType*/ ConvertUtils.CONSUMER_TYPE_USER_BATTERY, + /* foregroundUsageTimeInMs= */ FOREGROUND_TIME_MS, + /* foregroundSerUsageTimeInMs= */ FOREGROUND_SERVICE_TIME_MS, + /* backgroundUsageTimeInMs= */ BACKGROUND_TIME_MS, + /* screenOnTimeInMs= */ SCREEN_ON_TIME_MS, + /* consumePower= */ 0, + /* foregroundUsageConsumePower= */ 0, + /* foregroundServiceUsageConsumePower= */ 0, + /* backgroundUsageConsumePower= */ 0, + /* cachedUsageConsumePower= */ 0)); + when(mBatteryDiffEntry.getAppLabel()).thenReturn(APP_LABEL); + when(mBatteryDiffEntry.getAppIconId()).thenReturn(ICON_ID); + mFragment.mHeaderPreference = mHeaderPreference; mFragment.mState = mState; mFragment.mBatteryOptimizeUtils = mBatteryOptimizeUtils; @@ -191,6 +219,7 @@ public class AdvancedPowerUsageDetailTest { .when(mActivity) .startActivityAsUser(captor.capture(), nullable(UserHandle.class)); doAnswer(callable).when(mActivity).startActivity(captor.capture()); + doAnswer(callable).when(mContext).startActivity(captor.capture()); mAllowBackgroundUsagePreference = new PrimarySwitchPreference(mContext); mAllowBackgroundUsagePreference.setKey(KEY_ALLOW_BACKGROUND_USAGE); @@ -256,6 +285,7 @@ public class AdvancedPowerUsageDetailTest { @Test public void startBatteryDetailPage_invalidToShowSummary_noFGBDData() { + mBundle.clear(); AdvancedPowerUsageDetail.startBatteryDetailPage( mActivity, mFragment, mBatteryEntry, USAGE_PERCENT); @@ -267,6 +297,35 @@ public class AdvancedPowerUsageDetailTest { .isEqualTo(USAGE_PERCENT); } + @Test + public void startBatteryDetailPage_showSummary_hasFGBDData() { + final ArgumentCaptor captor = ArgumentCaptor.forClass(Intent.class); + mBundle.clear(); + AdvancedPowerUsageDetail.startBatteryDetailPage( + mContext, + mFragment.getMetricsCategory(), + mBatteryDiffEntry, + USAGE_PERCENT, + /* slotInformation= */ null, + /* showTimeInformation= */ true, + /* anomalyHintPrefKey= */ null, + /* anomalyHintText= */ null); + + verify(mContext).startActivity(captor.capture()); + assertThat(mBundle.getInt(AdvancedPowerUsageDetail.EXTRA_UID)).isEqualTo(UID); + assertThat(mBundle.getLong(AdvancedPowerUsageDetail.EXTRA_BACKGROUND_TIME)) + .isEqualTo(BACKGROUND_TIME_MS + FOREGROUND_SERVICE_TIME_MS); + assertThat(mBundle.getLong(AdvancedPowerUsageDetail.EXTRA_FOREGROUND_TIME)) + .isEqualTo(FOREGROUND_TIME_MS); + assertThat(mBundle.getLong(AdvancedPowerUsageDetail.EXTRA_SCREEN_ON_TIME)) + .isEqualTo(SCREEN_ON_TIME_MS); + assertThat(mBundle.getString(AdvancedPowerUsageDetail.EXTRA_POWER_USAGE_PERCENT)) + .isEqualTo(USAGE_PERCENT); + assertThat(mBundle.getString(AdvancedPowerUsageDetail.EXTRA_SLOT_TIME)) + .isEqualTo(null); + } + + @Test public void startBatteryDetailPage_noBatteryUsage_hasBasicData() { final ArgumentCaptor captor = ArgumentCaptor.forClass(Intent.class); @@ -292,6 +351,7 @@ public class AdvancedPowerUsageDetailTest { @Test public void startBatteryDetailPage_batteryEntryNotExisted_extractUidFromPackageName() throws PackageManager.NameNotFoundException { + mBundle.clear(); doReturn(UID).when(mPackageManager).getPackageUid(PACKAGE_NAME[0], 0 /* no flag */); AdvancedPowerUsageDetail.startBatteryDetailPage( diff --git a/tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryDiffDataTest.java b/tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryDiffDataTest.java index ffe3c44408f..d351ca3d33c 100644 --- a/tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryDiffDataTest.java +++ b/tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryDiffDataTest.java @@ -207,6 +207,7 @@ public class BatteryDiffDataTest { batteryHistEntry.mAppLabel, batteryHistEntry.mConsumerType, /* foregroundUsageTimeInMs= */ 0, + /* foregroundServiceUsageTimeInMs= */ 0, /* backgroundUsageTimeInMs= */ 0, /* screenOnTimeInMs= */ 0, consumePower, 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 d8b733cc155..6f1dce64cb6 100644 --- a/tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryDiffEntryTest.java +++ b/tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryDiffEntryTest.java @@ -111,8 +111,9 @@ public final class BatteryDiffEntryTest { /* legacyLabel= */ null, /*consumerType*/ ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /* foregroundUsageTimeInMs= */ 10001L, - /* backgroundUsageTimeInMs= */ 20002L, - /* screenOnTimeInMs= */ 30003L, + /* foregroundServiceUsageTimeInMs= */ 20002L, + /* backgroundUsageTimeInMs= */ 30003L, + /* screenOnTimeInMs= */ 40004L, /* consumePower= */ 22.0, /* foregroundUsageConsumePower= */ 10.0, /* foregroundServiceUsageConsumePower= */ 10.0, @@ -137,8 +138,9 @@ public final class BatteryDiffEntryTest { /* legacyLabel= */ null, /*consumerType*/ ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /* foregroundUsageTimeInMs= */ 10001L, - /* backgroundUsageTimeInMs= */ 20002L, - /* screenOnTimeInMs= */ 30003L, + /* foregroundServiceUsageTimeInMs= */ 20002L, + /* backgroundUsageTimeInMs= */ 30003L, + /* screenOnTimeInMs= */ 40004L, /* consumePower= */ 22.0, /* foregroundUsageConsumePower= */ 10.0, /* foregroundServiceUsageConsumePower= */ 10.0, @@ -165,6 +167,7 @@ public final class BatteryDiffEntryTest { /* legacyLabel= */ BatteryDiffEntry.SYSTEM_APPS_KEY, /*consumerType*/ ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /* foregroundUsageTimeInMs= */ 0, + /* foregroundServiceUsageTimeInMs= */ 0, /* backgroundUsageTimeInMs= */ 0, /* screenOnTimeInMs= */ 0, /* consumePower= */ 0, @@ -552,6 +555,7 @@ public final class BatteryDiffEntryTest { /* legacyLabel= */ null, /*consumerType*/ consumerType, /* foregroundUsageTimeInMs= */ 0, + /* foregroundServiceUsageTimeInMs= */ 0, /* backgroundUsageTimeInMs= */ 0, /* screenOnTimeInMs= */ 0, /* consumePower= */ 0, @@ -576,6 +580,7 @@ public final class BatteryDiffEntryTest { batteryHistEntry.mConsumerType, /* foregroundUsageTimeInMs= */ 0, /* backgroundUsageTimeInMs= */ 0, + /* foregroundServiceUsageTimeInMs= */ 0, /* screenOnTimeInMs= */ 0, consumePower, /* foregroundUsageConsumePower= */ 0, diff --git a/tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryEntryTest.java b/tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryEntryTest.java index 83b44583f83..450d058c229 100644 --- a/tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryEntryTest.java +++ b/tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryEntryTest.java @@ -195,7 +195,8 @@ public class BatteryEntryTest { @Test public void getTimeInForegroundMs_app() { - when(mUidBatteryConsumer.getTimeInStateMs(UidBatteryConsumer.STATE_FOREGROUND)) + when(mUidBatteryConsumer.getTimeInProcessStateMs( + UidBatteryConsumer.PROCESS_STATE_FOREGROUND)) .thenReturn(100L); final BatteryEntry entry = @@ -226,8 +227,9 @@ public class BatteryEntryTest { @Test public void getTimeInBackgroundMs_app() { - when(mUidBatteryConsumer.getTimeInStateMs(UidBatteryConsumer.STATE_BACKGROUND)) - .thenReturn(100L); + when(mUidBatteryConsumer.getTimeInProcessStateMs( + UidBatteryConsumer.PROCESS_STATE_BACKGROUND)) + .thenReturn(30L); final BatteryEntry entry = new BatteryEntry( @@ -239,7 +241,26 @@ public class BatteryEntryTest { null, null); - assertThat(entry.getTimeInBackgroundMs()).isEqualTo(100L); + assertThat(entry.getTimeInBackgroundMs()).isEqualTo(30L); + } + + @Test + public void getTimeInForegroundServiceMs_app() { + when(mUidBatteryConsumer.getTimeInProcessStateMs( + UidBatteryConsumer.PROCESS_STATE_FOREGROUND_SERVICE)) + .thenReturn(70L); + + final BatteryEntry entry = + new BatteryEntry( + RuntimeEnvironment.application, + mMockUserManager, + mUidBatteryConsumer, + false, + 0, + null, + null); + + assertThat(entry.getTimeInForegroundServiceMs()).isEqualTo(70L); } @Test 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 02800f754a9..dc868c8fa21 100644 --- a/tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryHistEntryTest.java +++ b/tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryHistEntryTest.java @@ -65,6 +65,7 @@ public final class BatteryHistEntryTest { 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()) @@ -105,6 +106,7 @@ public final class BatteryHistEntryTest { /* backgroundUsageConsumePower= */ 1.4, /* cachedUsageConsumePower= */ 1.5, /* foregroundUsageTimeInMs= */ 1234L, + /* foregroundServiceUsageTimeInMs= */ 3456L, /* backgroundUsageTimeInMs= */ 5689L, /* batteryLevel= */ 12), /* drainType= */ 3, @@ -211,6 +213,7 @@ public final class BatteryHistEntryTest { /* backgroundUsageConsumePower= */ 3, /* cachedUsageConsumePower= */ 4, /* foregroundUsageTimeInMs= */ 100, + /* foregroundServiceUsageTimeInMs= */ 150, /* backgroundUsageTimeInMs= */ 200, /* batteryLevel= */ 90); final BatteryHistEntry upperHistEntry = @@ -224,6 +227,7 @@ public final class BatteryHistEntryTest { /* backgroundUsageConsumePower= */ 6, /* cachedUsageConsumePower= */ 5, /* foregroundUsageTimeInMs= */ 200, + /* foregroundServiceUsageTimeInMs= */ 250, /* backgroundUsageTimeInMs= */ 300, /* batteryLevel= */ 80); @@ -244,6 +248,7 @@ public final class BatteryHistEntryTest { /* 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))); } @@ -264,6 +269,7 @@ public final class BatteryHistEntryTest { /* backgroundUsageConsumePower= */ 6, /* cachedUsageConsumePower= */ 5, /* foregroundUsageTimeInMs= */ 200, + /* foregroundServiceUsageTimeInMs= */ 250, /* backgroundUsageTimeInMs= */ 300, /* batteryLevel= */ 80); @@ -288,6 +294,7 @@ public final class BatteryHistEntryTest { /* 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); } @@ -317,6 +324,7 @@ public final class BatteryHistEntryTest { /* backgroundUsageConsumePower= */ 1.4, /* cachedUsageConsumePower= */ 1.5, /* foregroundUsageTimeInMs= */ 1234L, + /*foregroundServiceUsageTimeInMs=*/ 3456L, /* backgroundUsageTimeInMs= */ 5689L, /* batteryLevel= */ 12); } @@ -334,6 +342,7 @@ public final class BatteryHistEntryTest { double backgroundUsageConsumePower, double cachedUsageConsumePower, long foregroundUsageTimeInMs, + long foregroundServiceUsageTimeInMs, long backgroundUsageTimeInMs, int batteryLevel) { assertThat(entry.isValidEntry()).isTrue(); @@ -354,6 +363,7 @@ public final class BatteryHistEntryTest { 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).isEqualTo(ConvertUtils.CONSUMER_TYPE_SYSTEM_BATTERY); @@ -372,6 +382,7 @@ public final class BatteryHistEntryTest { double backgroundUsageConsumePower, double cachedUsageConsumePower, long foregroundUsageTimeInMs, + long foregroundServiceUsageTimeInMs, long backgroundUsageTimeInMs, int batteryLevel) { final MatrixCursor cursor = @@ -406,6 +417,7 @@ public final class BatteryHistEntryTest { .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/BatteryUsageBreakdownControllerTest.java b/tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryUsageBreakdownControllerTest.java index fc30702591b..5704be934e8 100644 --- a/tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryUsageBreakdownControllerTest.java +++ b/tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryUsageBreakdownControllerTest.java @@ -100,7 +100,8 @@ public final class BatteryUsageBreakdownControllerTest { /* legacyLabel= */ null, /* consumerType= */ ConvertUtils.CONSUMER_TYPE_UID_BATTERY, /* foregroundUsageTimeInMs= */ 1, - /* backgroundUsageTimeInMs= */ 2, + /* foregroundServiceUsageTimeInMs= */ 2, + /* backgroundUsageTimeInMs= */ 3, /* screenOnTimeInMs= */ 0, /* consumePower= */ 3, /* foregroundUsageConsumePower= */ 0, @@ -275,6 +276,7 @@ public final class BatteryUsageBreakdownControllerTest { /* isSystem= */ true, /* screenOnTimeInMs= */ 0, /* foregroundUsageTimeInMs= */ 0, + /* foregroundServiceUsageTimeInMs= */ 0, /* backgroundUsageTimeInMs= */ 0); batteryDiffEntry.mConsumePower = 0.8; batteryDiffEntry.setTotalConsumePower(100); @@ -293,6 +295,7 @@ public final class BatteryUsageBreakdownControllerTest { /* isSystem= */ true, /* screenOnTimeInMs= */ 0, /* foregroundUsageTimeInMs= */ 0, + /* foregroundServiceUsageTimeInMs= */ 0, /* backgroundUsageTimeInMs= */ 0); batteryDiffEntry.mConsumePower = 16; batteryDiffEntry.setTotalConsumePower(100); @@ -314,6 +317,7 @@ public final class BatteryUsageBreakdownControllerTest { /* isSystem= */ true, /* screenOnTimeInMs= */ 0, /* foregroundUsageTimeInMs= */ 0, + /* foregroundServiceUsageTimeInMs= */ 0, /* backgroundUsageTimeInMs= */ 0)); assertThat(pref.getSummary().toString().isEmpty()).isTrue(); } @@ -329,6 +333,7 @@ public final class BatteryUsageBreakdownControllerTest { /* isSystem= */ true, /* screenOnTimeInMs= */ 0, /* foregroundUsageTimeInMs= */ DateUtils.MINUTE_IN_MILLIS - 1, + /* foregroundServiceUsageTimeInMs= */ 0, /* backgroundUsageTimeInMs= */ 0)); assertThat(pref.getSummary().toString()).isEqualTo("Total: less than a min"); } @@ -344,6 +349,7 @@ public final class BatteryUsageBreakdownControllerTest { /* isSystem= */ true, /* screenOnTimeInMs= */ 0, /* foregroundUsageTimeInMs= */ DateUtils.MINUTE_IN_MILLIS * 2, + /* foregroundServiceUsageTimeInMs= */ 0, /* backgroundUsageTimeInMs= */ 0)); assertThat(pref.getSummary().toString()).isEqualTo("Total: 2 min"); } @@ -359,6 +365,7 @@ public final class BatteryUsageBreakdownControllerTest { /* isSystem= */ false, /* screenOnTimeInMs= */ 0, /* foregroundUsageTimeInMs= */ 0, + /* foregroundServiceUsageTimeInMs= */ 0, /* backgroundUsageTimeInMs= */ 0)); assertThat(pref.getSummary().toString().isEmpty()).isTrue(); } @@ -374,10 +381,27 @@ public final class BatteryUsageBreakdownControllerTest { /* isSystem= */ false, /* screenOnTimeInMs= */ 0, /* foregroundUsageTimeInMs= */ 0, + /* foregroundServiceUsageTimeInMs= */ 0, /* backgroundUsageTimeInMs= */ DateUtils.MINUTE_IN_MILLIS)); assertThat(pref.getSummary().toString()).isEqualTo("Background: 1 min"); } + @Test + public void setPreferenceSummary_appEntryWithFGSTime_expectedSummary() { + final PowerGaugePreference pref = new PowerGaugePreference(mContext); + pref.setSummary(PREF_SUMMARY); + + mBatteryUsageBreakdownController.setPreferenceSummary( + pref, + createBatteryDiffEntry( + /* isSystem= */ false, + /* screenOnTimeInMs= */ 0, + /* foregroundUsageTimeInMs= */ 0, + /* foregroundServiceUsageTimeInMs= */ DateUtils.MINUTE_IN_MILLIS / 2, + /* backgroundUsageTimeInMs= */ DateUtils.MINUTE_IN_MILLIS / 2)); + assertThat(pref.getSummary().toString()).isEqualTo("Background: 1 min"); + } + @Test public void setPreferenceSummary_appEntryScreenOnTimeOnly_expectedSummary() { final PowerGaugePreference pref = new PowerGaugePreference(mContext); @@ -389,6 +413,7 @@ public final class BatteryUsageBreakdownControllerTest { /* isSystem= */ false, /* screenOnTimeInMs= */ DateUtils.MINUTE_IN_MILLIS, /* foregroundUsageTimeInMs= */ 0, + /* foregroundServiceUsageTimeInMs= */ 0, /* backgroundUsageTimeInMs= */ 0)); assertThat(pref.getSummary().toString()).isEqualTo("Screen time: 1 min"); } @@ -404,6 +429,7 @@ public final class BatteryUsageBreakdownControllerTest { /* isSystem= */ false, /* screenOnTimeInMs= */ DateUtils.MINUTE_IN_MILLIS - 1, /* foregroundUsageTimeInMs= */ DateUtils.MINUTE_IN_MILLIS - 1, + /* foregroundServiceUsageTimeInMs= */ 0, /* backgroundUsageTimeInMs= */ DateUtils.MINUTE_IN_MILLIS - 1)); assertThat(pref.getSummary().toString()) .isEqualTo("Screen time: less than a min\nBackground: less than a min"); @@ -413,6 +439,7 @@ public final class BatteryUsageBreakdownControllerTest { boolean isSystem, long screenOnTimeInMs, long foregroundUsageTimeInMs, + long foregroundServiceUsageTimeInMs, long backgroundUsageTimeInMs) { final ContentValues contentValues = new ContentValues(); contentValues.put( @@ -435,6 +462,7 @@ public final class BatteryUsageBreakdownControllerTest { batteryHistEntry.mConsumerType, foregroundUsageTimeInMs, backgroundUsageTimeInMs, + foregroundServiceUsageTimeInMs, screenOnTimeInMs, /* consumePower= */ 0, /* foregroundUsageConsumePower= */ 0, 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 95b950f8959..950f8280215 100644 --- a/tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryUsageContentProviderTest.java +++ b/tests/robotests/src/com/android/settings/fuelgauge/batteryusage/BatteryUsageContentProviderTest.java @@ -290,6 +290,7 @@ public final class BatteryUsageContentProviderTest { .setPercentOfTotal(0.9) .setForegroundUsageTimeInMs(1000) .setBackgroundUsageTimeInMs(2000) + .setForegroundServiceUsageTimeInMs(1500) .setDrainType(1) .build(); final String expectedBatteryInformationString = 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 672bc54f908..e68b892ca7e 100644 --- a/tests/robotests/src/com/android/settings/fuelgauge/batteryusage/ConvertUtilsTest.java +++ b/tests/robotests/src/com/android/settings/fuelgauge/batteryusage/ConvertUtilsTest.java @@ -92,6 +92,7 @@ public final class ConvertUtilsTest { mMockBatteryEntry.mPercent = 0.3; when(mMockBatteryEntry.getTimeInForegroundMs()).thenReturn(1234L); when(mMockBatteryEntry.getTimeInBackgroundMs()).thenReturn(5689L); + when(mMockBatteryEntry.getTimeInForegroundServiceMs()).thenReturn(3456L); when(mMockBatteryEntry.getPowerComponentId()).thenReturn(-1); when(mMockBatteryEntry.getConsumerType()) .thenReturn(ConvertUtils.CONSUMER_TYPE_UID_BATTERY); @@ -133,6 +134,7 @@ public final class ConvertUtilsTest { assertThat(batteryInformation.getPercentOfTotal()).isEqualTo(0.3); assertThat(batteryInformation.getForegroundUsageTimeInMs()).isEqualTo(1234L); assertThat(batteryInformation.getBackgroundUsageTimeInMs()).isEqualTo(5689L); + assertThat(batteryInformation.getForegroundServiceUsageTimeInMs()).isEqualTo(3456L); assertThat(batteryInformation.getDrainType()).isEqualTo(-1); assertThat(deviceBatteryState.getBatteryLevel()).isEqualTo(12); assertThat(deviceBatteryState.getBatteryStatus()) @@ -157,6 +159,7 @@ public final class ConvertUtilsTest { mMockBatteryEntry.mPercent = 0.3; when(mMockBatteryEntry.getTimeInForegroundMs()).thenReturn(1234L); when(mMockBatteryEntry.getTimeInBackgroundMs()).thenReturn(5689L); + when(mMockBatteryEntry.getTimeInForegroundServiceMs()).thenReturn(3456L); when(mMockBatteryEntry.getConsumerType()) .thenReturn(ConvertUtils.CONSUMER_TYPE_SYSTEM_BATTERY); @@ -196,6 +199,7 @@ public final class ConvertUtilsTest { assertThat(batteryInformation.getPercentOfTotal()).isEqualTo(0.3); assertThat(batteryInformation.getForegroundUsageTimeInMs()).isEqualTo(1234L); assertThat(batteryInformation.getBackgroundUsageTimeInMs()).isEqualTo(5689L); + assertThat(batteryInformation.getForegroundServiceUsageTimeInMs()).isEqualTo(3456L); assertThat(batteryInformation.getDrainType()) .isEqualTo(BatteryConsumer.POWER_COMPONENT_CPU); assertThat(deviceBatteryState.getBatteryLevel()).isEqualTo(12); @@ -307,6 +311,7 @@ public final class ConvertUtilsTest { mMockBatteryEntry.mPercent = 0.3; when(mMockBatteryEntry.getTimeInForegroundMs()).thenReturn(1234L); when(mMockBatteryEntry.getTimeInBackgroundMs()).thenReturn(5689L); + when(mMockBatteryEntry.getTimeInForegroundServiceMs()).thenReturn(3456L); when(mMockBatteryEntry.getPowerComponentId()).thenReturn(expectedType); when(mMockBatteryEntry.getConsumerType()) .thenReturn(ConvertUtils.CONSUMER_TYPE_SYSTEM_BATTERY); @@ -331,6 +336,7 @@ public final class ConvertUtilsTest { assertThat(batteryHistEntry.mPercentOfTotal).isEqualTo(0.3); assertThat(batteryHistEntry.mForegroundUsageTimeInMs).isEqualTo(1234L); assertThat(batteryHistEntry.mBackgroundUsageTimeInMs).isEqualTo(5689L); + assertThat(batteryHistEntry.mForegroundServiceUsageTimeInMs).isEqualTo(3456L); assertThat(batteryHistEntry.mDrainType).isEqualTo(expectedType); assertThat(batteryHistEntry.mConsumerType) .isEqualTo(ConvertUtils.CONSUMER_TYPE_SYSTEM_BATTERY);