Merge "Add SystemBatteryConsumer.getPowerConsumedByApps()" into sc-dev

10 files changed, 147 insertions, 57 deletions

diff --git a/core/java/android/os/SystemBatteryConsumer.java b/core/java/android/os/SystemBatteryConsumer.java
index 06cff904a215..5f35332f4818 100644
--- a/core/java/android/os/SystemBatteryConsumer.java
+++ b/core/java/android/os/SystemBatteryConsumer.java
@@ -18,6 +18,7 @@ package android.os;
 
 import android.annotation.IntDef;
 import android.annotation.NonNull;
+import android.util.Slog;
 
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
@@ -31,6 +32,7 @@ import java.util.List;
  * {@hide}
  */
 public class SystemBatteryConsumer extends BatteryConsumer implements Parcelable {
+    private static final String TAG = "SystemBatteryConsumer";
 
     //                           ****************
     // This list must be kept current with atoms.proto (frameworks/base/cmds/statsd/src/atoms.proto)
@@ -72,6 +74,8 @@ public class SystemBatteryConsumer extends BatteryConsumer implements Parcelable
     @DrainType
     private final int mDrainType;
 
+    private final double mPowerConsumedByAppsMah;
+
     @DrainType
     public int getDrainType() {
         return mDrainType;
@@ -80,11 +84,23 @@ public class SystemBatteryConsumer extends BatteryConsumer implements Parcelable
     private SystemBatteryConsumer(@NonNull SystemBatteryConsumer.Builder builder) {
         super(builder.mPowerComponentsBuilder.build());
         mDrainType = builder.mDrainType;
+        mPowerConsumedByAppsMah = builder.mPowerConsumedByAppsMah;
+        if (mPowerConsumedByAppsMah > getConsumedPower()) {
+            Slog.wtf(TAG,
+                    "Power attributed to apps exceeds total: drain type = " + mDrainType
+                            + " total consumed power = " + getConsumedPower()
+                            + " power consumed by apps = " + mPowerConsumedByAppsMah);
+        }
     }
 
     private SystemBatteryConsumer(Parcel in) {
         super(new PowerComponents(in));
         mDrainType = in.readInt();
+        mPowerConsumedByAppsMah = in.readDouble();
+    }
+
+    public double getPowerConsumedByApps() {
+        return mPowerConsumedByAppsMah;
     }
 
     /**
@@ -94,6 +110,7 @@ public class SystemBatteryConsumer extends BatteryConsumer implements Parcelable
     public void writeToParcel(@NonNull Parcel dest, int flags) {
         super.writeToParcel(dest, flags);
         dest.writeInt(mDrainType);
+        dest.writeDouble(mPowerConsumedByAppsMah);
     }
 
     public static final Creator<SystemBatteryConsumer> CREATOR =
@@ -120,6 +137,7 @@ public class SystemBatteryConsumer extends BatteryConsumer implements Parcelable
     public static final class Builder extends BaseBuilder<Builder> {
         @DrainType
         private final int mDrainType;
+        private double mPowerConsumedByAppsMah;
         private List<UidBatteryConsumer.Builder> mUidBatteryConsumers;
 
         Builder(int customPowerComponentCount, int customTimeComponentCount,
@@ -129,6 +147,15 @@ public class SystemBatteryConsumer extends BatteryConsumer implements Parcelable
         }
 
         /**
+         * Sets the amount of power used by this system component that is attributed to apps.
+         * It should not exceed the total consumed power.
+         */
+        public Builder setPowerConsumedByApps(double powerConsumedByAppsMah) {
+            mPowerConsumedByAppsMah = powerConsumedByAppsMah;
+            return this;
+        }
+
+        /**
          * Add a UidBatteryConsumer to this SystemBatteryConsumer. For example,
          * the UidBatteryConsumer with the UID == {@link Process#BLUETOOTH_UID} should
          * be added to the SystemBatteryConsumer with the drain type == {@link
diff --git a/core/java/com/android/internal/os/BluetoothPowerCalculator.java b/core/java/com/android/internal/os/BluetoothPowerCalculator.java
index db1403479f8a..75a98133a8f3 100644
--- a/core/java/com/android/internal/os/BluetoothPowerCalculator.java
+++ b/core/java/com/android/internal/os/BluetoothPowerCalculator.java
@@ -84,16 +84,16 @@ public class BluetoothPowerCalculator extends PowerCalculator {
 
         // Subtract what the apps used, but clamp to 0.
         final long systemComponentDurationMs = Math.max(0, systemDurationMs - total.durationMs);
-        final double systemComponentPowerMah = Math.max(0, systemPowerMah - total.powerMah);
-        if (DEBUG && systemComponentPowerMah != 0) {
+        if (DEBUG) {
             Log.d(TAG, "Bluetooth active: time=" + (systemComponentDurationMs)
-                    + " power=" + formatCharge(systemComponentPowerMah));
+                    + " power=" + formatCharge(systemPowerMah));
         }
         systemBatteryConsumerBuilder
                 .setUsageDurationMillis(BatteryConsumer.TIME_COMPONENT_BLUETOOTH,
                         systemComponentDurationMs)
                 .setConsumedPower(BatteryConsumer.POWER_COMPONENT_BLUETOOTH,
-                        systemComponentPowerMah);
+                        Math.max(systemPowerMah, total.powerMah))
+                .setPowerConsumedByApps(total.powerMah);
     }
 
     private void calculateApp(UidBatteryConsumer.Builder app, PowerAndDuration total,
diff --git a/core/java/com/android/internal/os/MobileRadioPowerCalculator.java b/core/java/com/android/internal/os/MobileRadioPowerCalculator.java
index 498e1f2931a0..f6ef30cba369 100644
--- a/core/java/com/android/internal/os/MobileRadioPowerCalculator.java
+++ b/core/java/com/android/internal/os/MobileRadioPowerCalculator.java
@@ -42,8 +42,9 @@ public class MobileRadioPowerCalculator extends PowerCalculator {
 
     private static class PowerAndDuration {
         public long durationMs;
-        public double powerMah;
+        public double remainingPowerMah;
         public long totalAppDurationMs;
+        public double totalAppPowerMah;
         public long signalDurationMs;
         public long noCoverageDurationMs;
     }
@@ -103,12 +104,14 @@ public class MobileRadioPowerCalculator extends PowerCalculator {
         calculateRemaining(total, batteryStats, rawRealtimeUs,
                 query.shouldForceUsePowerProfileModel());
 
-        if (total.powerMah != 0) {
+        if (total.remainingPowerMah != 0 || total.totalAppPowerMah != 0) {
             builder.getOrCreateSystemBatteryConsumerBuilder(
                     SystemBatteryConsumer.DRAIN_TYPE_MOBILE_RADIO)
                     .setUsageDurationMillis(BatteryConsumer.TIME_COMPONENT_MOBILE_RADIO,
                             total.durationMs)
-                    .setConsumedPower(BatteryConsumer.POWER_COMPONENT_MOBILE_RADIO, total.powerMah);
+                    .setConsumedPower(BatteryConsumer.POWER_COMPONENT_MOBILE_RADIO,
+                            total.remainingPowerMah + total.totalAppPowerMah)
+                    .setPowerConsumedByApps(total.totalAppPowerMah);
         }
     }
 
@@ -120,6 +123,7 @@ public class MobileRadioPowerCalculator extends PowerCalculator {
 
         final double powerMah = calculatePower(u, powerPerPacketMah, radioActiveDurationMs,
                 shouldForceUsePowerProfileModel);
+        total.totalAppPowerMah += powerMah;
 
         app.setUsageDurationMillis(BatteryConsumer.TIME_COMPONENT_MOBILE_RADIO,
                 radioActiveDurationMs)
@@ -142,14 +146,14 @@ public class MobileRadioPowerCalculator extends PowerCalculator {
 
         BatterySipper radio = new BatterySipper(BatterySipper.DrainType.CELL, null, 0);
         calculateRemaining(total, batteryStats, rawRealtimeUs, false);
-        if (total.powerMah != 0) {
+        if (total.remainingPowerMah != 0) {
             if (total.signalDurationMs != 0) {
                 radio.noCoveragePercent =
                         total.noCoverageDurationMs * 100.0 / total.signalDurationMs;
             }
             radio.mobileActive = total.durationMs;
             radio.mobileActiveCount = batteryStats.getMobileRadioActiveUnknownCount(statsType);
-            radio.mobileRadioPowerMah = total.powerMah;
+            radio.mobileRadioPowerMah = total.remainingPowerMah;
             radio.sumPower();
         }
         if (radio.totalPowerMah > 0) {
@@ -265,7 +269,7 @@ public class MobileRadioPowerCalculator extends PowerCalculator {
             }
         }
         total.durationMs = radioActiveTimeMs;
-        total.powerMah = powerMah;
+        total.remainingPowerMah = powerMah;
         total.signalDurationMs = signalTimeMs;
     }
 
diff --git a/core/java/com/android/internal/os/ScreenPowerCalculator.java b/core/java/com/android/internal/os/ScreenPowerCalculator.java
index d94bb31f58bf..ad574440f216 100644
--- a/core/java/com/android/internal/os/ScreenPowerCalculator.java
+++ b/core/java/com/android/internal/os/ScreenPowerCalculator.java
@@ -66,11 +66,7 @@ public class ScreenPowerCalculator extends PowerCalculator {
                 batteryStats, rawRealtimeUs, BatteryStats.STATS_SINCE_CHARGED,
                 query.shouldForceUsePowerProfileModel());
 
-        builder.getOrCreateSystemBatteryConsumerBuilder(SystemBatteryConsumer.DRAIN_TYPE_SCREEN)
-                .setUsageDurationMillis(BatteryConsumer.TIME_COMPONENT_USAGE,
-                        totalPowerAndDuration.durationMs)
-                .setConsumedPower(BatteryConsumer.POWER_COMPONENT_USAGE,
-                        totalPowerAndDuration.powerMah);
+        double totalAppPower = 0;
 
         // Now deal with each app's UidBatteryConsumer. The results are stored in the
         // BatteryConsumer.POWER_COMPONENT_SCREEN power component, which is considered smeared,
@@ -87,11 +83,20 @@ public class ScreenPowerCalculator extends PowerCalculator {
                                 appPowerAndDuration.durationMs)
                         .setConsumedPower(BatteryConsumer.POWER_COMPONENT_SCREEN,
                                 appPowerAndDuration.powerMah);
+                totalAppPower += appPowerAndDuration.powerMah;
             }
         } else {
             smearScreenBatteryDrain(uidBatteryConsumerBuilders, totalPowerAndDuration,
                     rawRealtimeUs);
+            totalAppPower = totalPowerAndDuration.powerMah;
         }
+
+        builder.getOrCreateSystemBatteryConsumerBuilder(SystemBatteryConsumer.DRAIN_TYPE_SCREEN)
+                .setUsageDurationMillis(BatteryConsumer.TIME_COMPONENT_USAGE,
+                        totalPowerAndDuration.durationMs)
+                .setConsumedPower(BatteryConsumer.POWER_COMPONENT_USAGE,
+                        Math.max(totalPowerAndDuration.powerMah, totalAppPower))
+                .setPowerConsumedByApps(totalAppPower);
     }
 
     /**
diff --git a/core/java/com/android/internal/os/WifiPowerCalculator.java b/core/java/com/android/internal/os/WifiPowerCalculator.java
index b6bfde709cb8..d95506b00677 100644
--- a/core/java/com/android/internal/os/WifiPowerCalculator.java
+++ b/core/java/com/android/internal/os/WifiPowerCalculator.java
@@ -121,7 +121,8 @@ public class WifiPowerCalculator extends PowerCalculator {
                 .setUsageDurationMillis(BatteryConsumer.TIME_COMPONENT_WIFI,
                         powerDurationAndTraffic.durationMs)
                 .setConsumedPower(BatteryConsumer.POWER_COMPONENT_WIFI,
-                        powerDurationAndTraffic.powerMah);
+                        totalAppPowerMah + powerDurationAndTraffic.powerMah)
+                .setPowerConsumedByApps(totalAppPowerMah);
     }
 
     /**
diff --git a/core/tests/coretests/src/com/android/internal/os/BatteryUsageStatsTest.java b/core/tests/coretests/src/com/android/internal/os/BatteryUsageStatsTest.java
index fc3be1337b45..a18a88cb2ca8 100644
--- a/core/tests/coretests/src/com/android/internal/os/BatteryUsageStatsTest.java
+++ b/core/tests/coretests/src/com/android/internal/os/BatteryUsageStatsTest.java
@@ -96,7 +96,8 @@ public class BatteryUsageStatsTest {
                 .setUsageDurationMillis(
                         BatteryConsumer.TIME_COMPONENT_CPU, 10300)
                 .setUsageDurationForCustomComponentMillis(
-                        BatteryConsumer.FIRST_CUSTOM_TIME_COMPONENT_ID, 10400);
+                        BatteryConsumer.FIRST_CUSTOM_TIME_COMPONENT_ID, 10400)
+                .setPowerConsumedByApps(20000);
 
         return builder.build();
     }
@@ -148,6 +149,7 @@ public class BatteryUsageStatsTest {
                 assertThat(systemBatteryConsumer.getUsageDurationForCustomComponentMillis(
                         BatteryConsumer.FIRST_CUSTOM_TIME_COMPONENT_ID)).isEqualTo(10400);
                 assertThat(systemBatteryConsumer.getConsumedPower()).isEqualTo(20300);
+                assertThat(systemBatteryConsumer.getPowerConsumedByApps()).isEqualTo(20000);
             } else {
                 fail("Unexpected drain type " + systemBatteryConsumer.getDrainType());
             }
diff --git a/core/tests/coretests/src/com/android/internal/os/BluetoothPowerCalculatorTest.java b/core/tests/coretests/src/com/android/internal/os/BluetoothPowerCalculatorTest.java
index 71d7668bbcfa..2769b163ecd2 100644
--- a/core/tests/coretests/src/com/android/internal/os/BluetoothPowerCalculatorTest.java
+++ b/core/tests/coretests/src/com/android/internal/os/BluetoothPowerCalculatorTest.java
@@ -69,7 +69,7 @@ public class BluetoothPowerCalculatorTest {
                 0.24722, 15000);
         assertBluetoothPowerAndDuration(
                 mStatsRule.getSystemBatteryConsumer(SystemBatteryConsumer.DRAIN_TYPE_BLUETOOTH),
-                0.15833, 9000);
+                0.51944, 9000, 0.51944, 0.36111);
     }
 
     @Test
@@ -98,7 +98,7 @@ public class BluetoothPowerCalculatorTest {
                 0.2, 15000);
         assertBluetoothPowerAndDuration(
                 mStatsRule.getSystemBatteryConsumer(SystemBatteryConsumer.DRAIN_TYPE_BLUETOOTH),
-                0.15, 9000);
+                0.45, 9000, 0.45, 0.3);
     }
 
     private void setDurationsAndPower(
@@ -123,4 +123,15 @@ public class BluetoothPowerCalculatorTest {
 
         assertThat(usageDurationMillis).isEqualTo(durationMs);
     }
+
+    private void assertBluetoothPowerAndDuration(@Nullable SystemBatteryConsumer batteryConsumer,
+            double powerMah, int durationMs, double consumedPower, double attributedPower) {
+        assertBluetoothPowerAndDuration(batteryConsumer, powerMah, durationMs);
+
+        assertThat(batteryConsumer.getConsumedPower())
+                .isWithin(PRECISION).of(consumedPower);
+
+        assertThat(batteryConsumer.getPowerConsumedByApps())
+                .isWithin(PRECISION).of(attributedPower);
+    }
 }
diff --git a/core/tests/coretests/src/com/android/internal/os/MobileRadioPowerCalculatorTest.java b/core/tests/coretests/src/com/android/internal/os/MobileRadioPowerCalculatorTest.java
index ae59a546642d..813bc9f43662 100644
--- a/core/tests/coretests/src/com/android/internal/os/MobileRadioPowerCalculatorTest.java
+++ b/core/tests/coretests/src/com/android/internal/os/MobileRadioPowerCalculatorTest.java
@@ -105,7 +105,11 @@ public class MobileRadioPowerCalculatorTest {
         SystemBatteryConsumer consumer =
                 mStatsRule.getSystemBatteryConsumer(SystemBatteryConsumer.DRAIN_TYPE_MOBILE_RADIO);
         assertThat(consumer.getConsumedPower(BatteryConsumer.POWER_COMPONENT_MOBILE_RADIO))
-                .isWithin(PRECISION).of(1.44440);
+                .isWithin(PRECISION).of(2.2444);
+        assertThat(consumer.getConsumedPower())
+                .isWithin(PRECISION).of(2.2444);
+        assertThat(consumer.getPowerConsumedByApps())
+                .isWithin(PRECISION).of(0.8);
 
         UidBatteryConsumer uidConsumer = mStatsRule.getUidBatteryConsumer(APP_UID);
         assertThat(uidConsumer.getConsumedPower(BatteryConsumer.POWER_COMPONENT_MOBILE_RADIO))
@@ -156,9 +160,11 @@ public class MobileRadioPowerCalculatorTest {
         SystemBatteryConsumer consumer =
                 mStatsRule.getSystemBatteryConsumer(SystemBatteryConsumer.DRAIN_TYPE_MOBILE_RADIO);
 
-        // 100000000 uAs * (1 mA / 1000 uA) * (1 h / 3600 s) = 2.77777 mAh
+        // 100000000 uAs * (1 mA / 1000 uA) * (1 h / 3600 s) + 1.53934 (apps)= 4.31711 mAh
         assertThat(consumer.getConsumedPower(BatteryConsumer.POWER_COMPONENT_MOBILE_RADIO))
-                .isWithin(PRECISION).of(2.77777);
+                .isWithin(PRECISION).of(4.31711);
+        assertThat(consumer.getPowerConsumedByApps())
+                .isWithin(PRECISION).of(1.53934);
 
         UidBatteryConsumer uidConsumer = mStatsRule.getUidBatteryConsumer(APP_UID);
         assertThat(uidConsumer.getConsumedPower(BatteryConsumer.POWER_COMPONENT_MOBILE_RADIO))
diff --git a/core/tests/coretests/src/com/android/internal/os/ScreenPowerCalculatorTest.java b/core/tests/coretests/src/com/android/internal/os/ScreenPowerCalculatorTest.java
index f3cf81ca3e86..d296afa00dbc 100644
--- a/core/tests/coretests/src/com/android/internal/os/ScreenPowerCalculatorTest.java
+++ b/core/tests/coretests/src/com/android/internal/os/ScreenPowerCalculatorTest.java
@@ -52,17 +52,26 @@ public class ScreenPowerCalculatorTest {
         BatteryStatsImpl batteryStats = mStatsRule.getBatteryStats();
 
         batteryStats.noteScreenStateLocked(Display.STATE_ON, 0, 0, 0);
-        batteryStats.updateDisplayMeasuredEnergyStatsLocked(0, Display.STATE_ON, 2 * MINUTE_IN_MS);
+        batteryStats.updateDisplayMeasuredEnergyStatsLocked(0, Display.STATE_ON, 0);
+        setProcState(APP_UID1, ActivityManager.PROCESS_STATE_TOP, true,
+                0, 0);
 
-        setFgState(APP_UID1, true, 2 * MINUTE_IN_MS, 2 * MINUTE_IN_MS);
-        setFgState(APP_UID1, false, 20 * MINUTE_IN_MS, 20 * MINUTE_IN_MS);
-        setFgState(APP_UID2, true, 30 * MINUTE_IN_MS, 30 * MINUTE_IN_MS);
+        batteryStats.updateDisplayMeasuredEnergyStatsLocked(200_000_000, Display.STATE_ON,
+                15 * MINUTE_IN_MS);
+
+        setProcState(APP_UID1, ActivityManager.PROCESS_STATE_CACHED_EMPTY, false,
+                20 * MINUTE_IN_MS, 20 * MINUTE_IN_MS);
+
+        setProcState(APP_UID2, ActivityManager.PROCESS_STATE_TOP, true,
+                20 * MINUTE_IN_MS, 20 * MINUTE_IN_MS);
 
         batteryStats.updateDisplayMeasuredEnergyStatsLocked(300_000_000, Display.STATE_ON,
                 60 * MINUTE_IN_MS);
 
         batteryStats.noteScreenStateLocked(Display.STATE_OFF,
                 80 * MINUTE_IN_MS, 80 * MINUTE_IN_MS, 80 * MINUTE_IN_MS);
+        setProcState(APP_UID2, ActivityManager.PROCESS_STATE_TOP_SLEEPING, false,
+                80 * MINUTE_IN_MS, 80 * MINUTE_IN_MS);
 
         batteryStats.updateDisplayMeasuredEnergyStatsLocked(100_000_000, Display.STATE_DOZE,
                 120 * MINUTE_IN_MS);
@@ -79,28 +88,33 @@ public class ScreenPowerCalculatorTest {
         assertThat(consumer.getUsageDurationMillis(BatteryConsumer.TIME_COMPONENT_USAGE))
                 .isEqualTo(80 * MINUTE_IN_MS);
 
-        // 400000000 uAs * (1 mA / 1000 uA) * (1 h / 3600 s)  = 111.11111 mAh
+        // 600000000 uAs * (1 mA / 1000 uA) * (1 h / 3600 s)  = 166.66666 mAh
         assertThat(consumer.getConsumedPower(BatteryConsumer.POWER_COMPONENT_USAGE))
-                .isWithin(PRECISION).of(111.11111);
+                .isWithin(PRECISION).of(166.66666);
+        assertThat(consumer.getConsumedPower())
+                .isWithin(PRECISION).of(166.66666);
+        assertThat(consumer.getPowerConsumedByApps())
+                .isWithin(PRECISION).of(166.66666);
 
         UidBatteryConsumer uid1 = mStatsRule.getUidBatteryConsumer(APP_UID1);
         assertThat(uid1.getUsageDurationMillis(BatteryConsumer.TIME_COMPONENT_SCREEN))
-                .isEqualTo(18 * MINUTE_IN_MS);
+                .isEqualTo(20 * MINUTE_IN_MS);
 
-        // Uid1 ran for 18 minutes out of the total 48 min of foreground time during the first
-        // Display update. Uid1 charge = 18 / 48 * 300000000 uAs = 31.25 mAh
+        // Uid1 took all of the foreground time during the first Display update.
+        // It also ran for 5 out of 45 min during the second Display update:
+        // Uid1 charge = 200000000 + 5 / 45 * 300000000 mAs = 64.81 mAh
         assertThat(uid1.getConsumedPower(BatteryConsumer.POWER_COMPONENT_SCREEN))
-                .isWithin(PRECISION).of(31.25);
+                .isWithin(PRECISION).of(64.81481);
 
         UidBatteryConsumer uid2 = mStatsRule.getUidBatteryConsumer(APP_UID2);
         assertThat(uid2.getUsageDurationMillis(BatteryConsumer.TIME_COMPONENT_SCREEN))
-                .isEqualTo(90 * MINUTE_IN_MS);
+                .isEqualTo(60 * MINUTE_IN_MS);
 
-        // Uid2 ran for 30 minutes out of the total 48 min of foreground time during the first
-        // Display update and then took all of the time during the second Display update.
-        // Uid1 charge = 30 / 48 * 300000000 + 100000000 mAs = 79.86111 mAh
+        // Uid2 ran for 40 minutes out of the total 45 min of foreground time during the second
+        // Display update and then took all of the time during the third Display update.
+        // Uid2 charge = 40 / 45 * 300000000 + 100000000 mAs = 101.85 mAh
         assertThat(uid2.getConsumedPower(BatteryConsumer.POWER_COMPONENT_SCREEN))
-                .isWithin(PRECISION).of(79.86111);
+                .isWithin(PRECISION).of(101.85185);
     }
 
     @Test
@@ -108,18 +122,22 @@ public class ScreenPowerCalculatorTest {
         BatteryStatsImpl batteryStats = mStatsRule.getBatteryStats();
 
         batteryStats.noteScreenStateLocked(Display.STATE_ON, 0, 0, 0);
-
-        setFgState(APP_UID1, true, 2 * MINUTE_IN_MS, 2 * MINUTE_IN_MS);
+        batteryStats.noteScreenBrightnessLocked(255, 0, 0);
+        setProcState(APP_UID1, ActivityManager.PROCESS_STATE_TOP, true,
+                0, 0);
 
         batteryStats.noteScreenBrightnessLocked(100, 5 * MINUTE_IN_MS, 5 * MINUTE_IN_MS);
         batteryStats.noteScreenBrightnessLocked(200, 10 * MINUTE_IN_MS, 10 * MINUTE_IN_MS);
 
-        setFgState(APP_UID1, false, 20 * MINUTE_IN_MS, 20 * MINUTE_IN_MS);
-
-        setFgState(APP_UID2, true, 30 * MINUTE_IN_MS, 30 * MINUTE_IN_MS);
+        setProcState(APP_UID1, ActivityManager.PROCESS_STATE_CACHED_EMPTY, false,
+                20 * MINUTE_IN_MS, 20 * MINUTE_IN_MS);
+        setProcState(APP_UID2, ActivityManager.PROCESS_STATE_TOP, true,
+                20 * MINUTE_IN_MS, 20 * MINUTE_IN_MS);
 
         batteryStats.noteScreenStateLocked(Display.STATE_OFF,
                 80 * MINUTE_IN_MS, 80 * MINUTE_IN_MS, 80 * MINUTE_IN_MS);
+        setProcState(APP_UID2, ActivityManager.PROCESS_STATE_TOP_SLEEPING, false,
+                80 * MINUTE_IN_MS, 80 * MINUTE_IN_MS);
 
         mStatsRule.setTime(120 * MINUTE_IN_US, 120 * MINUTE_IN_US);
 
@@ -134,31 +152,39 @@ public class ScreenPowerCalculatorTest {
         assertThat(consumer.getUsageDurationMillis(BatteryConsumer.TIME_COMPONENT_USAGE))
                 .isEqualTo(80 * MINUTE_IN_MS);
         assertThat(consumer.getConsumedPower(BatteryConsumer.POWER_COMPONENT_USAGE))
-                .isWithin(PRECISION).of(88.4);
+                .isWithin(PRECISION).of(92.0);
+        assertThat(consumer.getConsumedPower())
+                .isWithin(PRECISION).of(92.0);
+        assertThat(consumer.getPowerConsumedByApps())
+                .isWithin(PRECISION).of(92.0);
 
         UidBatteryConsumer uid1 = mStatsRule.getUidBatteryConsumer(APP_UID1);
         assertThat(uid1.getUsageDurationMillis(BatteryConsumer.TIME_COMPONENT_SCREEN))
-                .isEqualTo(18 * MINUTE_IN_MS);
+                .isEqualTo(20 * MINUTE_IN_MS);
+
+        // Uid1 took 20 out of the total of 80 min of foreground activity
+        // Uid1 charge = 20 / 80 * 92.0 = 23.0 mAh
         assertThat(uid1.getConsumedPower(BatteryConsumer.POWER_COMPONENT_SCREEN))
-                .isWithin(PRECISION).of(14.73333);
+                .isWithin(PRECISION).of(23.0);
 
         UidBatteryConsumer uid2 = mStatsRule.getUidBatteryConsumer(APP_UID2);
         assertThat(uid2.getUsageDurationMillis(BatteryConsumer.TIME_COMPONENT_SCREEN))
-                .isEqualTo(90 * MINUTE_IN_MS);
+                .isEqualTo(60 * MINUTE_IN_MS);
+
+        // Uid2 took 60 out of the total of 80 min of foreground activity
+        // Uid2 charge = 60 / 80 * 92.0 = 69.0 mAh
         assertThat(uid2.getConsumedPower(BatteryConsumer.POWER_COMPONENT_SCREEN))
-                .isWithin(PRECISION).of(73.66666);
+                .isWithin(PRECISION).of(69.0);
     }
 
-    private void setFgState(int uid, boolean fgOn, long realtimeMs, long uptimeMs) {
+    private void setProcState(int uid, int procState, boolean resumed, long realtimeMs,
+            long uptimeMs) {
         BatteryStatsImpl batteryStats = mStatsRule.getBatteryStats();
-        if (fgOn) {
+        batteryStats.noteUidProcessStateLocked(uid, procState, realtimeMs, uptimeMs);
+        if (resumed) {
             batteryStats.noteActivityResumedLocked(uid, realtimeMs, uptimeMs);
-            batteryStats.noteUidProcessStateLocked(uid, ActivityManager.PROCESS_STATE_TOP,
-                    realtimeMs, uptimeMs);
         } else {
             batteryStats.noteActivityPausedLocked(uid, realtimeMs, uptimeMs);
-            batteryStats.noteUidProcessStateLocked(uid, ActivityManager.PROCESS_STATE_CACHED_EMPTY,
-                    realtimeMs, uptimeMs);
         }
     }
 }
diff --git a/core/tests/coretests/src/com/android/internal/os/WifiPowerCalculatorTest.java b/core/tests/coretests/src/com/android/internal/os/WifiPowerCalculatorTest.java
index 2e23dc8dbba8..5df91dd00f59 100644
--- a/core/tests/coretests/src/com/android/internal/os/WifiPowerCalculatorTest.java
+++ b/core/tests/coretests/src/com/android/internal/os/WifiPowerCalculatorTest.java
@@ -99,7 +99,9 @@ public class WifiPowerCalculatorTest {
         assertThat(systemConsumer.getUsageDurationMillis(BatteryConsumer.TIME_COMPONENT_WIFI))
                 .isEqualTo(5577);
         assertThat(systemConsumer.getConsumedPower(BatteryConsumer.POWER_COMPONENT_WIFI))
-                .isWithin(PRECISION).of(0.645200);
+                .isWithin(PRECISION).of(1.11153);
+        assertThat(systemConsumer.getPowerConsumedByApps())
+                .isWithin(PRECISION).of(0.466333);
     }
 
     @Test
@@ -125,7 +127,9 @@ public class WifiPowerCalculatorTest {
                 .isEqualTo(5577);
         /* Same ratio as in testPowerControllerBasedModel_nonMeasured but scaled by 1_000_000uC. */
         assertThat(systemConsumer.getConsumedPower(BatteryConsumer.POWER_COMPONENT_WIFI))
-                .isWithin(PRECISION).of(0.645200 / (0.2214666 + 0.645200) * 1_000_000 / 3600000);
+                .isWithin(PRECISION).of(1.11153 / (0.2214666 + 0.645200) * 1_000_000 / 3600000);
+        assertThat(systemConsumer.getPowerConsumedByApps())
+                .isWithin(PRECISION).of(0.14946);
     }
 
     /** Sets up batterystats object with prepopulated network & timer data for Timer-model tests. */
@@ -163,7 +167,9 @@ public class WifiPowerCalculatorTest {
         assertThat(systemConsumer.getUsageDurationMillis(BatteryConsumer.TIME_COMPONENT_WIFI))
                 .isEqualTo(2222);
         assertThat(systemConsumer.getConsumedPower(BatteryConsumer.POWER_COMPONENT_WIFI))
-                .isWithin(PRECISION).of(0.8759216);
+                .isWithin(PRECISION).of(2.575000);
+        assertThat(systemConsumer.getPowerConsumedByApps())
+                .isWithin(PRECISION).of(1.69907);
     }
 
     @Test
@@ -190,6 +196,8 @@ public class WifiPowerCalculatorTest {
                 .isEqualTo(2222);
         /* Same ratio as in testTimerBasedModel_nonMeasured but scaled by 1_000_000uC. */
         assertThat(systemConsumer.getConsumedPower(BatteryConsumer.POWER_COMPONENT_WIFI))
-                .isWithin(PRECISION).of(0.8759216 / (0.8231573 + 0.8759216) * 1_000_000 / 3600000);
+                .isWithin(PRECISION).of(2.575000 / (0.8231573 + 0.8759216) * 1_000_000 / 3600000);
+        assertThat(systemConsumer.getPowerConsumedByApps())
+                .isWithin(PRECISION).of(0.277777);
     }
 }