diff options
24 files changed, 481 insertions, 233 deletions
diff --git a/core/java/android/os/BatteryConsumer.java b/core/java/android/os/BatteryConsumer.java index 2b6f336848c3..033148379041 100644 --- a/core/java/android/os/BatteryConsumer.java +++ b/core/java/android/os/BatteryConsumer.java @@ -124,6 +124,30 @@ public abstract class BatteryConsumer { public static final int FIRST_CUSTOM_TIME_COMPONENT_ID = 1000; public static final int LAST_CUSTOM_TIME_COMPONENT_ID = 9999; + /** + * Identifiers of models used for power estimation. + * + * @hide + */ + @IntDef(prefix = {"POWER_MODEL_"}, value = { + POWER_MODEL_POWER_PROFILE, + POWER_MODEL_MEASURED_ENERGY, + }) + @Retention(RetentionPolicy.SOURCE) + public @interface PowerModel { + } + + /** + * Power model that is based on average consumption rates that hardware components + * consume in various states. + */ + public static final int POWER_MODEL_POWER_PROFILE = 0; + + /** + * Power model that is based on energy consumption measured by on-device power monitors. + */ + public static final int POWER_MODEL_MEASURED_ENERGY = 1; + private final PowerComponents mPowerComponents; protected BatteryConsumer(@NonNull PowerComponents powerComponents) { @@ -149,6 +173,16 @@ public abstract class BatteryConsumer { } /** + * Returns the ID of the model that was used for power estimation. + * + * @param componentId The ID of the power component, e.g. + * {@link BatteryConsumer#POWER_COMPONENT_CPU}. + */ + public @PowerModel int getPowerModel(@BatteryConsumer.PowerComponent int componentId) { + return mPowerComponents.getPowerModel(componentId); + } + + /** * Returns the amount of drain attributed to the specified custom drain type. * * @param componentId The ID of the custom power component. @@ -188,9 +222,10 @@ public abstract class BatteryConsumer { protected abstract static class BaseBuilder<T extends BaseBuilder<?>> { final PowerComponents.Builder mPowerComponentsBuilder; - public BaseBuilder(int customPowerComponentCount, int customTimeComponentCount) { + public BaseBuilder(int customPowerComponentCount, int customTimeComponentCount, + boolean includePowerModels) { mPowerComponentsBuilder = new PowerComponents.Builder(customPowerComponentCount, - customTimeComponentCount); + customTimeComponentCount, includePowerModels); } /** @@ -200,10 +235,23 @@ public abstract class BatteryConsumer { * {@link BatteryConsumer#POWER_COMPONENT_CPU}. * @param componentPower Amount of consumed power in mAh. */ - @SuppressWarnings("unchecked") @NonNull public T setConsumedPower(@PowerComponent int componentId, double componentPower) { - mPowerComponentsBuilder.setConsumedPower(componentId, componentPower); + return setConsumedPower(componentId, componentPower, POWER_MODEL_POWER_PROFILE); + } + + /** + * Sets the amount of drain attributed to the specified drain type, e.g. CPU, WiFi etc. + * + * @param componentId The ID of the power component, e.g. + * {@link BatteryConsumer#POWER_COMPONENT_CPU}. + * @param componentPower Amount of consumed power in mAh. + */ + @SuppressWarnings("unchecked") + @NonNull + public T setConsumedPower(@PowerComponent int componentId, double componentPower, + @PowerModel int powerModel) { + mPowerComponentsBuilder.setConsumedPower(componentId, componentPower, powerModel); return (T) this; } diff --git a/core/java/android/os/BatteryUsageStats.java b/core/java/android/os/BatteryUsageStats.java index a0721c32fc2a..58441d8a099c 100644 --- a/core/java/android/os/BatteryUsageStats.java +++ b/core/java/android/os/BatteryUsageStats.java @@ -261,6 +261,7 @@ public final class BatteryUsageStats implements Parcelable { public static final class Builder { private final int mCustomPowerComponentCount; private final int mCustomTimeComponentCount; + private final boolean mIncludePowerModels; private long mStatsStartTimestampMs; private int mDischargePercentage; private double mDischargedPowerLowerBoundMah; @@ -277,8 +278,14 @@ public final class BatteryUsageStats implements Parcelable { private List<BatteryStats.HistoryTag> mHistoryTagPool; public Builder(int customPowerComponentCount, int customTimeComponentCount) { + this(customPowerComponentCount, customTimeComponentCount, false); + } + + public Builder(int customPowerComponentCount, int customTimeComponentCount, + boolean includePowerModels) { mCustomPowerComponentCount = customPowerComponentCount; mCustomTimeComponentCount = customTimeComponentCount; + mIncludePowerModels = includePowerModels; } /** @@ -360,7 +367,7 @@ public final class BatteryUsageStats implements Parcelable { UidBatteryConsumer.Builder builder = mUidBatteryConsumerBuilders.get(uid); if (builder == null) { builder = new UidBatteryConsumer.Builder(mCustomPowerComponentCount, - mCustomTimeComponentCount, batteryStatsUid); + mCustomTimeComponentCount, mIncludePowerModels, batteryStatsUid); mUidBatteryConsumerBuilders.put(uid, builder); } return builder; @@ -376,7 +383,7 @@ public final class BatteryUsageStats implements Parcelable { SystemBatteryConsumer.Builder builder = mSystemBatteryConsumerBuilders.get(drainType); if (builder == null) { builder = new SystemBatteryConsumer.Builder(mCustomPowerComponentCount, - mCustomTimeComponentCount, drainType); + mCustomTimeComponentCount, mIncludePowerModels, drainType); mSystemBatteryConsumerBuilders.put(drainType, builder); } return builder; @@ -391,7 +398,7 @@ public final class BatteryUsageStats implements Parcelable { UserBatteryConsumer.Builder builder = mUserBatteryConsumerBuilders.get(userId); if (builder == null) { builder = new UserBatteryConsumer.Builder(mCustomPowerComponentCount, - mCustomTimeComponentCount, userId); + mCustomTimeComponentCount, mIncludePowerModels, userId); mUserBatteryConsumerBuilders.put(userId, builder); } return builder; diff --git a/core/java/android/os/BatteryUsageStatsQuery.java b/core/java/android/os/BatteryUsageStatsQuery.java index 85861bc1d2aa..50804422e92f 100644 --- a/core/java/android/os/BatteryUsageStatsQuery.java +++ b/core/java/android/os/BatteryUsageStatsQuery.java @@ -60,6 +60,12 @@ public final class BatteryUsageStatsQuery implements Parcelable { */ public static final int FLAG_BATTERY_USAGE_STATS_INCLUDE_HISTORY = 2; + /** + * Indicates that identifiers of power models used for computations of power + * consumption should be included in the BatteryUsageStats. + */ + public static final int FLAG_BATTERY_USAGE_STATS_INCLUDE_POWER_MODELS = 4; + private static final long DEFAULT_MAX_STATS_AGE_MS = 5 * 60 * 1000; private final int mFlags; @@ -187,6 +193,17 @@ public final class BatteryUsageStatsQuery implements Parcelable { } /** + * Requests to return identifiers of models that were used for estimation + * of power consumption. + * + * Should only be used for testing and debugging. + */ + public Builder includePowerModels() { + mFlags |= BatteryUsageStatsQuery.FLAG_BATTERY_USAGE_STATS_INCLUDE_POWER_MODELS; + return this; + } + + /** * Set the client's tolerance for stale battery stats. The data may be up to * this many milliseconds out-of-date. */ diff --git a/core/java/android/os/PowerComponents.java b/core/java/android/os/PowerComponents.java index d239b23b6ff6..238f4518b7d3 100644 --- a/core/java/android/os/PowerComponents.java +++ b/core/java/android/os/PowerComponents.java @@ -33,12 +33,14 @@ class PowerComponents { private final double[] mPowerComponentsMah; private final long[] mTimeComponentsMs; private final int mCustomPowerComponentCount; + private final byte[] mPowerModels; PowerComponents(@NonNull Builder builder) { mCustomPowerComponentCount = builder.mCustomPowerComponentCount; mPowerComponentsMah = builder.mPowerComponentsMah; mTimeComponentsMs = builder.mTimeComponentsMs; mTotalConsumedPowerMah = builder.getTotalPower(); + mPowerModels = builder.mPowerModels; } PowerComponents(@NonNull Parcel source) { @@ -46,6 +48,12 @@ class PowerComponents { mCustomPowerComponentCount = source.readInt(); mPowerComponentsMah = source.createDoubleArray(); mTimeComponentsMs = source.createLongArray(); + if (source.readBoolean()) { + mPowerModels = new byte[BatteryConsumer.POWER_COMPONENT_COUNT]; + source.readByteArray(mPowerModels); + } else { + mPowerModels = null; + } } /** Writes contents to Parcel */ @@ -54,6 +62,12 @@ class PowerComponents { dest.writeInt(mCustomPowerComponentCount); dest.writeDoubleArray(mPowerComponentsMah); dest.writeLongArray(mTimeComponentsMs); + if (mPowerModels != null) { + dest.writeBoolean(true); + dest.writeByteArray(mPowerModels); + } else { + dest.writeBoolean(false); + } } /** @@ -103,6 +117,15 @@ class PowerComponents { } } + @BatteryConsumer.PowerModel + int getPowerModel(@BatteryConsumer.PowerComponent int component) { + if (mPowerModels == null) { + throw new IllegalStateException( + "Power model IDs were not requested in the BatteryUsageStatsQuery"); + } + return mPowerModels[component]; + } + /** * Returns the amount of time used by the specified component, e.g. CPU, WiFi etc. * @@ -148,14 +171,21 @@ class PowerComponents { private final double[] mPowerComponentsMah; private final int mCustomPowerComponentCount; private final long[] mTimeComponentsMs; + private final byte[] mPowerModels; - Builder(int customPowerComponentCount, int customTimeComponentCount) { + Builder(int customPowerComponentCount, int customTimeComponentCount, + boolean includePowerModels) { mCustomPowerComponentCount = customPowerComponentCount; int powerComponentCount = BatteryConsumer.POWER_COMPONENT_COUNT + customPowerComponentCount; mPowerComponentsMah = new double[powerComponentCount]; mTimeComponentsMs = new long[BatteryConsumer.TIME_COMPONENT_COUNT + customTimeComponentCount]; + if (includePowerModels) { + mPowerModels = new byte[BatteryConsumer.POWER_COMPONENT_COUNT]; + } else { + mPowerModels = null; + } } /** @@ -167,7 +197,7 @@ class PowerComponents { */ @NonNull public Builder setConsumedPower(@BatteryConsumer.PowerComponent int componentId, - double componentPower) { + double componentPower, @BatteryConsumer.PowerModel int powerModel) { if (componentId >= BatteryConsumer.POWER_COMPONENT_COUNT) { throw new IllegalArgumentException( "Unsupported power component ID: " + componentId); @@ -178,6 +208,9 @@ class PowerComponents { throw new IllegalArgumentException( "Unsupported power component ID: " + componentId); } + if (mPowerModels != null) { + mPowerModels[componentId] = (byte) powerModel; + } return this; } diff --git a/core/java/android/os/SystemBatteryConsumer.java b/core/java/android/os/SystemBatteryConsumer.java index 5f35332f4818..e973e4c1044e 100644 --- a/core/java/android/os/SystemBatteryConsumer.java +++ b/core/java/android/os/SystemBatteryConsumer.java @@ -141,8 +141,8 @@ public class SystemBatteryConsumer extends BatteryConsumer implements Parcelable private List<UidBatteryConsumer.Builder> mUidBatteryConsumers; Builder(int customPowerComponentCount, int customTimeComponentCount, - @DrainType int drainType) { - super(customPowerComponentCount, customTimeComponentCount); + boolean includePowerModels, @DrainType int drainType) { + super(customPowerComponentCount, customTimeComponentCount, includePowerModels); mDrainType = drainType; } diff --git a/core/java/android/os/UidBatteryConsumer.java b/core/java/android/os/UidBatteryConsumer.java index dfa0c396485d..87c263b3dd38 100644 --- a/core/java/android/os/UidBatteryConsumer.java +++ b/core/java/android/os/UidBatteryConsumer.java @@ -140,8 +140,8 @@ public final class UidBatteryConsumer extends BatteryConsumer implements Parcela private boolean mExcludeFromBatteryUsageStats; public Builder(int customPowerComponentCount, int customTimeComponentCount, - @NonNull BatteryStats.Uid batteryStatsUid) { - super(customPowerComponentCount, customTimeComponentCount); + boolean includePowerModels, @NonNull BatteryStats.Uid batteryStatsUid) { + super(customPowerComponentCount, customTimeComponentCount, includePowerModels); mBatteryStatsUid = batteryStatsUid; mUid = batteryStatsUid.getUid(); } diff --git a/core/java/android/os/UserBatteryConsumer.java b/core/java/android/os/UserBatteryConsumer.java index 94e567f368b0..78322088a3a4 100644 --- a/core/java/android/os/UserBatteryConsumer.java +++ b/core/java/android/os/UserBatteryConsumer.java @@ -77,8 +77,9 @@ public class UserBatteryConsumer extends BatteryConsumer implements Parcelable { private final int mUserId; private List<UidBatteryConsumer.Builder> mUidBatteryConsumers; - Builder(int customPowerComponentCount, int customTimeComponentCount, int userId) { - super(customPowerComponentCount, customTimeComponentCount); + Builder(int customPowerComponentCount, int customTimeComponentCount, + boolean includePowerModels, int userId) { + super(customPowerComponentCount, customTimeComponentCount, includePowerModels); mUserId = userId; } diff --git a/core/java/com/android/internal/os/AmbientDisplayPowerCalculator.java b/core/java/com/android/internal/os/AmbientDisplayPowerCalculator.java index 586607e413d9..2f4958223270 100644 --- a/core/java/com/android/internal/os/AmbientDisplayPowerCalculator.java +++ b/core/java/com/android/internal/os/AmbientDisplayPowerCalculator.java @@ -44,14 +44,15 @@ public class AmbientDisplayPowerCalculator extends PowerCalculator { @Override public void calculate(BatteryUsageStats.Builder builder, BatteryStats batteryStats, long rawRealtimeUs, long rawUptimeUs, BatteryUsageStatsQuery query) { + final long measuredEnergyUC = batteryStats.getScreenDozeMeasuredBatteryConsumptionUC(); + final int powerModel = getPowerModel(measuredEnergyUC, query); final long durationMs = calculateDuration(batteryStats, rawRealtimeUs, BatteryStats.STATS_SINCE_CHARGED); - final double powerMah = getMeasuredOrEstimatedPower( - batteryStats.getScreenDozeMeasuredBatteryConsumptionUC(), - mPowerEstimator, durationMs, query.shouldForceUsePowerProfileModel()); + final double powerMah = getMeasuredOrEstimatedPower(powerModel, + measuredEnergyUC, mPowerEstimator, durationMs); builder.getOrCreateSystemBatteryConsumerBuilder( SystemBatteryConsumer.DRAIN_TYPE_AMBIENT_DISPLAY) - .setConsumedPower(BatteryConsumer.POWER_COMPONENT_USAGE, powerMah) + .setConsumedPower(BatteryConsumer.POWER_COMPONENT_USAGE, powerMah, powerModel) .setUsageDurationMillis(BatteryConsumer.TIME_COMPONENT_USAGE, durationMs); } @@ -64,10 +65,12 @@ public class AmbientDisplayPowerCalculator extends PowerCalculator { @Override public void calculate(List<BatterySipper> sippers, BatteryStats batteryStats, long rawRealtimeUs, long rawUptimeUs, int statsType, SparseArray<UserHandle> asUsers) { + final long measuredEnergyUC = batteryStats.getScreenDozeMeasuredBatteryConsumptionUC(); final long durationMs = calculateDuration(batteryStats, rawRealtimeUs, statsType); - final double powerMah = getMeasuredOrEstimatedPower( + final int powerModel = getPowerModel(measuredEnergyUC); + final double powerMah = getMeasuredOrEstimatedPower(powerModel, batteryStats.getScreenDozeMeasuredBatteryConsumptionUC(), - mPowerEstimator, durationMs, false); + mPowerEstimator, durationMs); if (powerMah > 0) { BatterySipper bs = new BatterySipper(BatterySipper.DrainType.AMBIENT_DISPLAY, null, 0); bs.usagePowerMah = powerMah; diff --git a/core/java/com/android/internal/os/BatteryUsageStatsProvider.java b/core/java/com/android/internal/os/BatteryUsageStatsProvider.java index f8ae0c1858f8..49c564b8a737 100644 --- a/core/java/com/android/internal/os/BatteryUsageStatsProvider.java +++ b/core/java/com/android/internal/os/BatteryUsageStatsProvider.java @@ -132,9 +132,12 @@ public class BatteryUsageStatsProvider { // TODO(b/174186358): read extra time component number from configuration final int customTimeComponentCount = 0; - final BatteryUsageStats.Builder batteryUsageStatsBuilder = - new BatteryUsageStats.Builder(customPowerComponentCount, customTimeComponentCount) - .setStatsStartTimestamp(mStats.getStartClockTime()); + final boolean includePowerModels = (query.getFlags() + & BatteryUsageStatsQuery.FLAG_BATTERY_USAGE_STATS_INCLUDE_POWER_MODELS) != 0; + + final BatteryUsageStats.Builder batteryUsageStatsBuilder = new BatteryUsageStats.Builder( + customPowerComponentCount, customTimeComponentCount, includePowerModels); + batteryUsageStatsBuilder.setStatsStartTimestamp(mStats.getStartClockTime()); SparseArray<? extends BatteryStats.Uid> uidStats = mStats.getUidStats(); for (int i = uidStats.size() - 1; i >= 0; i--) { diff --git a/core/java/com/android/internal/os/BluetoothPowerCalculator.java b/core/java/com/android/internal/os/BluetoothPowerCalculator.java index 75a98133a8f3..a418dfff5d8f 100644 --- a/core/java/com/android/internal/os/BluetoothPowerCalculator.java +++ b/core/java/com/android/internal/os/BluetoothPowerCalculator.java @@ -15,8 +15,6 @@ */ package com.android.internal.os; -import static android.os.BatteryStats.POWER_DATA_UNAVAILABLE; - import android.os.BatteryConsumer; import android.os.BatteryStats; import android.os.BatteryStats.ControllerActivityCounter; @@ -75,12 +73,13 @@ public class BluetoothPowerCalculator extends PowerCalculator { } } - final long measuredChargeUC = query.shouldForceUsePowerProfileModel() ? - POWER_DATA_UNAVAILABLE : batteryStats.getBluetoothMeasuredBatteryConsumptionUC(); + final long measuredChargeUC = batteryStats.getBluetoothMeasuredBatteryConsumptionUC(); + final int powerModel = getPowerModel(measuredChargeUC, query); final ControllerActivityCounter activityCounter = batteryStats.getBluetoothControllerActivity(); final long systemDurationMs = calculateDuration(activityCounter); - final double systemPowerMah = calculatePowerMah(measuredChargeUC, activityCounter); + final double systemPowerMah = + calculatePowerMah(powerModel, measuredChargeUC, activityCounter); // Subtract what the apps used, but clamp to 0. final long systemComponentDurationMs = Math.max(0, systemDurationMs - total.durationMs); @@ -92,23 +91,22 @@ public class BluetoothPowerCalculator extends PowerCalculator { .setUsageDurationMillis(BatteryConsumer.TIME_COMPONENT_BLUETOOTH, systemComponentDurationMs) .setConsumedPower(BatteryConsumer.POWER_COMPONENT_BLUETOOTH, - Math.max(systemPowerMah, total.powerMah)) + Math.max(systemPowerMah, total.powerMah), powerModel) .setPowerConsumedByApps(total.powerMah); } private void calculateApp(UidBatteryConsumer.Builder app, PowerAndDuration total, BatteryUsageStatsQuery query) { - - final long measuredChargeUC = query.shouldForceUsePowerProfileModel() ? - POWER_DATA_UNAVAILABLE : + final long measuredChargeUC = app.getBatteryStatsUid().getBluetoothMeasuredBatteryConsumptionUC(); + final int powerModel = getPowerModel(measuredChargeUC, query); final ControllerActivityCounter activityCounter = app.getBatteryStatsUid().getBluetoothControllerActivity(); final long durationMs = calculateDuration(activityCounter); - final double powerMah = calculatePowerMah(measuredChargeUC, activityCounter); + final double powerMah = calculatePowerMah(powerModel, measuredChargeUC, activityCounter); app.setUsageDurationMillis(BatteryConsumer.TIME_COMPONENT_BLUETOOTH, durationMs) - .setConsumedPower(BatteryConsumer.POWER_COMPONENT_BLUETOOTH, powerMah); + .setConsumedPower(BatteryConsumer.POWER_COMPONENT_BLUETOOTH, powerMah, powerModel); total.durationMs += durationMs; total.powerMah += powerMah; @@ -132,10 +130,12 @@ public class BluetoothPowerCalculator extends PowerCalculator { BatterySipper bs = new BatterySipper(BatterySipper.DrainType.BLUETOOTH, null, 0); final long measuredChargeUC = batteryStats.getBluetoothMeasuredBatteryConsumptionUC(); + final int powerModel = getPowerModel(measuredChargeUC); final ControllerActivityCounter activityCounter = batteryStats.getBluetoothControllerActivity(); final long systemDurationMs = calculateDuration(activityCounter); - final double systemPowerMah = calculatePowerMah(measuredChargeUC, activityCounter); + final double systemPowerMah = + calculatePowerMah(powerModel, measuredChargeUC, activityCounter); // Subtract what the apps used, but clamp to 0. final double powerMah = Math.max(0, systemPowerMah - total.powerMah); @@ -165,9 +165,10 @@ public class BluetoothPowerCalculator extends PowerCalculator { PowerAndDuration total) { final long measuredChargeUC = u.getBluetoothMeasuredBatteryConsumptionUC(); + final int powerModel = getPowerModel(measuredChargeUC); final ControllerActivityCounter activityCounter = u.getBluetoothControllerActivity(); final long durationMs = calculateDuration(activityCounter); - final double powerMah = calculatePowerMah(measuredChargeUC, activityCounter); + final double powerMah = calculatePowerMah(powerModel, measuredChargeUC, activityCounter); app.bluetoothRunningTimeMs = durationMs; app.bluetoothPowerMah = powerMah; @@ -189,10 +190,12 @@ public class BluetoothPowerCalculator extends PowerCalculator { } /** Returns bluetooth power usage based on the best data available. */ - private double calculatePowerMah(long measuredChargeUC, ControllerActivityCounter counter) { - if (measuredChargeUC != POWER_DATA_UNAVAILABLE) { + private double calculatePowerMah(@BatteryConsumer.PowerModel int powerModel, + long measuredChargeUC, ControllerActivityCounter counter) { + if (powerModel == BatteryConsumer.POWER_MODEL_MEASURED_ENERGY) { return uCtoMah(measuredChargeUC); } + if (counter == null) { return 0; } diff --git a/core/java/com/android/internal/os/CpuPowerCalculator.java b/core/java/com/android/internal/os/CpuPowerCalculator.java index b15543a26b4c..4aafec555182 100644 --- a/core/java/com/android/internal/os/CpuPowerCalculator.java +++ b/core/java/com/android/internal/os/CpuPowerCalculator.java @@ -91,10 +91,12 @@ public class CpuPowerCalculator extends PowerCalculator { private void calculateApp(UidBatteryConsumer.Builder app, BatteryStats.Uid u, BatteryUsageStatsQuery query, Result result) { - calculatePowerAndDuration(u, BatteryStats.STATS_SINCE_CHARGED, - query.shouldForceUsePowerProfileModel(), result); + final long consumptionUC = u.getCpuMeasuredBatteryConsumptionUC(); + final int powerModel = getPowerModel(consumptionUC, query); + calculatePowerAndDuration(u, powerModel, consumptionUC, BatteryStats.STATS_SINCE_CHARGED, + result); - app.setConsumedPower(BatteryConsumer.POWER_COMPONENT_CPU, result.powerMah) + app.setConsumedPower(BatteryConsumer.POWER_COMPONENT_CPU, result.powerMah, powerModel) .setUsageDurationMillis(BatteryConsumer.TIME_COMPONENT_CPU, result.durationMs) .setUsageDurationMillis(BatteryConsumer.TIME_COMPONENT_CPU_FOREGROUND, result.durationFgMs) @@ -114,7 +116,9 @@ public class CpuPowerCalculator extends PowerCalculator { } private void calculateApp(BatterySipper app, BatteryStats.Uid u, int statsType, Result result) { - calculatePowerAndDuration(u, statsType, false, result); + final long consumptionUC = u.getCpuMeasuredBatteryConsumptionUC(); + final int powerModel = getPowerModel(consumptionUC); + calculatePowerAndDuration(u, powerModel, consumptionUC, statsType, result); app.cpuPowerMah = result.powerMah; app.cpuTimeMs = result.durationMs; @@ -122,16 +126,20 @@ public class CpuPowerCalculator extends PowerCalculator { app.packageWithHighestDrain = result.packageWithHighestDrain; } - private void calculatePowerAndDuration(BatteryStats.Uid u, int statsType, - boolean forceUsePowerProfileModel, Result result) { + private void calculatePowerAndDuration(BatteryStats.Uid u, + @BatteryConsumer.PowerModel int powerModel, long consumptionUC, int statsType, + Result result) { long durationMs = (u.getUserCpuTimeUs(statsType) + u.getSystemCpuTimeUs(statsType)) / 1000; final double powerMah; - final long consumptionUC = u.getCpuMeasuredBatteryConsumptionUC(); - if (forceUsePowerProfileModel || consumptionUC == BatteryStats.POWER_DATA_UNAVAILABLE) { - powerMah = calculateUidModeledPowerMah(u, statsType); - } else { - powerMah = uCtoMah(consumptionUC); + switch(powerModel) { + case BatteryConsumer.POWER_MODEL_MEASURED_ENERGY: + powerMah = uCtoMah(consumptionUC); + break; + case BatteryConsumer.POWER_MODEL_POWER_PROFILE: + default: + powerMah = calculateUidModeledPowerMah(u, statsType); + break; } if (DEBUG && (durationMs != 0 || powerMah != 0)) { diff --git a/core/java/com/android/internal/os/GnssPowerCalculator.java b/core/java/com/android/internal/os/GnssPowerCalculator.java index 97c4fd8b7b7a..0e0870de4f5f 100644 --- a/core/java/com/android/internal/os/GnssPowerCalculator.java +++ b/core/java/com/android/internal/os/GnssPowerCalculator.java @@ -52,28 +52,30 @@ public class GnssPowerCalculator extends PowerCalculator { builder.getUidBatteryConsumerBuilders(); for (int i = uidBatteryConsumerBuilders.size() - 1; i >= 0; i--) { final UidBatteryConsumer.Builder app = uidBatteryConsumerBuilders.valueAt(i); - calculateApp(app, app.getBatteryStatsUid(), rawRealtimeUs, rawUptimeUs, query, - averageGnssPowerMa); + final long consumptionUC = + app.getBatteryStatsUid().getGnssMeasuredBatteryConsumptionUC(); + final int powerModel = getPowerModel(consumptionUC, query); + calculateApp(app, app.getBatteryStatsUid(), powerModel, rawRealtimeUs, + averageGnssPowerMa, consumptionUC); } } private void calculateApp(UidBatteryConsumer.Builder app, BatteryStats.Uid u, - long rawRealtimeUs, long rawUptimeUs, BatteryUsageStatsQuery query, - double averageGnssPowerMa) { + @BatteryConsumer.PowerModel int powerModel, long rawRealtimeUs, + double averageGnssPowerMa, long measuredChargeUC) { final long durationMs = computeDuration(u, rawRealtimeUs, BatteryStats.STATS_SINCE_CHARGED); - - final long measuredChargeUC = u.getGnssMeasuredBatteryConsumptionUC(); - final boolean isMeasuredPowerAvailable = !query.shouldForceUsePowerProfileModel() - && measuredChargeUC != BatteryStats.POWER_DATA_UNAVAILABLE; - final double powerMah; - if (isMeasuredPowerAvailable) { - powerMah = uCtoMah(measuredChargeUC); - } else { - powerMah = computePower(durationMs, averageGnssPowerMa); + switch (powerModel) { + case BatteryConsumer.POWER_MODEL_MEASURED_ENERGY: + powerMah = uCtoMah(measuredChargeUC); + break; + case BatteryConsumer.POWER_MODEL_POWER_PROFILE: + default: + powerMah = computePower(durationMs, averageGnssPowerMa); } + app.setUsageDurationMillis(BatteryConsumer.TIME_COMPONENT_GNSS, durationMs) - .setConsumedPower(BatteryConsumer.POWER_COMPONENT_GNSS, powerMah); + .setConsumedPower(BatteryConsumer.POWER_COMPONENT_GNSS, powerMah, powerModel); } @Override @@ -83,24 +85,28 @@ public class GnssPowerCalculator extends PowerCalculator { for (int i = sippers.size() - 1; i >= 0; i--) { final BatterySipper app = sippers.get(i); if (app.drainType == BatterySipper.DrainType.APP) { - calculateApp(app, app.uidObj, rawRealtimeUs, statsType, averageGnssPowerMa, false); + final long consumptionUC = + app.uidObj.getGnssMeasuredBatteryConsumptionUC(); + final int powerModel = getPowerModel(consumptionUC); + calculateApp(app, app.uidObj, powerModel, rawRealtimeUs, averageGnssPowerMa, + consumptionUC); } } } - protected void calculateApp(BatterySipper app, BatteryStats.Uid u, long rawRealtimeUs, - int statsType, double averageGnssPowerMa, boolean shouldForceUsePowerProfileModel) { + private void calculateApp(BatterySipper app, BatteryStats.Uid u, + @BatteryConsumer.PowerModel int powerModel, long rawRealtimeUs, + double averageGnssPowerMa, long measuredChargeUC) { final long durationMs = computeDuration(u, rawRealtimeUs, BatteryStats.STATS_SINCE_CHARGED); - final long measuredChargeUC = u.getGnssMeasuredBatteryConsumptionUC(); - final boolean isMeasuredPowerAvailable = shouldForceUsePowerProfileModel - && measuredChargeUC != BatteryStats.POWER_DATA_UNAVAILABLE; - final double powerMah; - if (isMeasuredPowerAvailable) { - powerMah = uCtoMah(measuredChargeUC); - } else { - powerMah = computePower(durationMs, averageGnssPowerMa); + switch (powerModel) { + case BatteryConsumer.POWER_MODEL_MEASURED_ENERGY: + powerMah = uCtoMah(measuredChargeUC); + break; + case BatteryConsumer.POWER_MODEL_POWER_PROFILE: + default: + powerMah = computePower(durationMs, averageGnssPowerMa); } app.gpsTimeMs = durationMs; diff --git a/core/java/com/android/internal/os/MobileRadioPowerCalculator.java b/core/java/com/android/internal/os/MobileRadioPowerCalculator.java index f6ef30cba369..d441d4529aca 100644 --- a/core/java/com/android/internal/os/MobileRadioPowerCalculator.java +++ b/core/java/com/android/internal/os/MobileRadioPowerCalculator.java @@ -97,37 +97,41 @@ public class MobileRadioPowerCalculator extends PowerCalculator { for (int i = uidBatteryConsumerBuilders.size() - 1; i >= 0; i--) { final UidBatteryConsumer.Builder app = uidBatteryConsumerBuilders.valueAt(i); final BatteryStats.Uid uid = app.getBatteryStatsUid(); - calculateApp(app, uid, powerPerPacketMah, total, - query.shouldForceUsePowerProfileModel()); + calculateApp(app, uid, powerPerPacketMah, total, query); } - calculateRemaining(total, batteryStats, rawRealtimeUs, - query.shouldForceUsePowerProfileModel()); + final long consumptionUC = batteryStats.getMobileRadioMeasuredBatteryConsumptionUC(); + final int powerModel = getPowerModel(consumptionUC, query); + calculateRemaining(total, powerModel, batteryStats, rawRealtimeUs, consumptionUC); if (total.remainingPowerMah != 0 || total.totalAppPowerMah != 0) { builder.getOrCreateSystemBatteryConsumerBuilder( - SystemBatteryConsumer.DRAIN_TYPE_MOBILE_RADIO) + SystemBatteryConsumer.DRAIN_TYPE_MOBILE_RADIO) .setUsageDurationMillis(BatteryConsumer.TIME_COMPONENT_MOBILE_RADIO, total.durationMs) .setConsumedPower(BatteryConsumer.POWER_COMPONENT_MOBILE_RADIO, - total.remainingPowerMah + total.totalAppPowerMah) + total.remainingPowerMah + total.totalAppPowerMah, + powerModel) .setPowerConsumedByApps(total.totalAppPowerMah); } } private void calculateApp(UidBatteryConsumer.Builder app, BatteryStats.Uid u, double powerPerPacketMah, PowerAndDuration total, - boolean shouldForceUsePowerProfileModel) { + BatteryUsageStatsQuery query) { final long radioActiveDurationMs = calculateDuration(u, BatteryStats.STATS_SINCE_CHARGED); total.totalAppDurationMs += radioActiveDurationMs; - final double powerMah = calculatePower(u, powerPerPacketMah, radioActiveDurationMs, - shouldForceUsePowerProfileModel); + final long consumptionUC = u.getMobileRadioMeasuredBatteryConsumptionUC(); + final int powerModel = getPowerModel(consumptionUC, query); + final double powerMah = calculatePower(u, powerModel, powerPerPacketMah, + radioActiveDurationMs, consumptionUC); total.totalAppPowerMah += powerMah; app.setUsageDurationMillis(BatteryConsumer.TIME_COMPONENT_MOBILE_RADIO, - radioActiveDurationMs) - .setConsumedPower(BatteryConsumer.POWER_COMPONENT_MOBILE_RADIO, powerMah); + radioActiveDurationMs) + .setConsumedPower(BatteryConsumer.POWER_COMPONENT_MOBILE_RADIO, powerMah, + powerModel); } @Override @@ -140,12 +144,14 @@ public class MobileRadioPowerCalculator extends PowerCalculator { final BatterySipper app = sippers.get(i); if (app.drainType == BatterySipper.DrainType.APP) { final BatteryStats.Uid u = app.uidObj; - calculateApp(app, u, statsType, mobilePowerPerPacket, total, false); + calculateApp(app, u, statsType, mobilePowerPerPacket, total); } } BatterySipper radio = new BatterySipper(BatterySipper.DrainType.CELL, null, 0); - calculateRemaining(total, batteryStats, rawRealtimeUs, false); + final long consumptionUC = batteryStats.getMobileRadioMeasuredBatteryConsumptionUC(); + final int powerModel = getPowerModel(consumptionUC); + calculateRemaining(total, powerModel, batteryStats, rawRealtimeUs, consumptionUC); if (total.remainingPowerMah != 0) { if (total.signalDurationMs != 0) { radio.noCoveragePercent = @@ -162,12 +168,13 @@ public class MobileRadioPowerCalculator extends PowerCalculator { } private void calculateApp(BatterySipper app, BatteryStats.Uid u, int statsType, - double powerPerPacketMah, PowerAndDuration total, - boolean shouldForceUsePowerProfileModel) { + double powerPerPacketMah, PowerAndDuration total) { app.mobileActive = calculateDuration(u, statsType); - app.mobileRadioPowerMah = calculatePower(u, powerPerPacketMah, app.mobileActive, - shouldForceUsePowerProfileModel); + final long consumptionUC = u.getMobileRadioMeasuredBatteryConsumptionUC(); + final int powerModel = getPowerModel(consumptionUC); + app.mobileRadioPowerMah = calculatePower(u, powerModel, powerPerPacketMah, app.mobileActive, + consumptionUC); total.totalAppDurationMs += app.mobileActive; // Add cost of mobile traffic. @@ -193,13 +200,9 @@ public class MobileRadioPowerCalculator extends PowerCalculator { return u.getMobileRadioActiveTime(statsType) / 1000; } - private double calculatePower(BatteryStats.Uid u, double powerPerPacketMah, - long radioActiveDurationMs, boolean shouldForceUsePowerProfileModel) { - - final long measuredChargeUC = u.getMobileRadioMeasuredBatteryConsumptionUC(); - final boolean isMeasuredPowerAvailable = !shouldForceUsePowerProfileModel - && measuredChargeUC != BatteryStats.POWER_DATA_UNAVAILABLE; - if (isMeasuredPowerAvailable) { + private double calculatePower(BatteryStats.Uid u, @BatteryConsumer.PowerModel int powerModel, + double powerPerPacketMah, long radioActiveDurationMs, long measuredChargeUC) { + if (powerModel == BatteryConsumer.POWER_MODEL_MEASURED_ENERGY) { return uCtoMah(measuredChargeUC); } @@ -220,23 +223,20 @@ public class MobileRadioPowerCalculator extends PowerCalculator { } } - private void calculateRemaining(MobileRadioPowerCalculator.PowerAndDuration total, - BatteryStats batteryStats, long rawRealtimeUs, - boolean shouldForceUsePowerProfileModel) { + private void calculateRemaining(PowerAndDuration total, + @BatteryConsumer.PowerModel int powerModel, BatteryStats batteryStats, + long rawRealtimeUs, long consumptionUC) { long signalTimeMs = 0; double powerMah = 0; - final long measuredChargeUC = batteryStats.getMobileRadioMeasuredBatteryConsumptionUC(); - final boolean isMeasuredPowerAvailable = !shouldForceUsePowerProfileModel - && measuredChargeUC != BatteryStats.POWER_DATA_UNAVAILABLE; - if (isMeasuredPowerAvailable) { - powerMah = uCtoMah(measuredChargeUC); + if (powerModel == BatteryConsumer.POWER_MODEL_MEASURED_ENERGY) { + powerMah = uCtoMah(consumptionUC); } for (int i = 0; i < NUM_SIGNAL_STRENGTH_LEVELS; i++) { long strengthTimeMs = batteryStats.getPhoneSignalStrengthTime(i, rawRealtimeUs, BatteryStats.STATS_SINCE_CHARGED) / 1000; - if (!isMeasuredPowerAvailable) { + if (powerModel == BatteryConsumer.POWER_MODEL_POWER_PROFILE) { final double p = calcIdlePowerAtSignalStrengthMah(strengthTimeMs, i); if (DEBUG && p != 0) { Log.d(TAG, "Cell strength #" + i + ": time=" + strengthTimeMs + " power=" @@ -256,7 +256,7 @@ public class MobileRadioPowerCalculator extends PowerCalculator { BatteryStats.STATS_SINCE_CHARGED) / 1000; long remainingActiveTimeMs = radioActiveTimeMs - total.totalAppDurationMs; - if (!isMeasuredPowerAvailable) { + if (powerModel == BatteryConsumer.POWER_MODEL_POWER_PROFILE) { final double p = calcScanTimePowerMah(scanningTimeMs); if (DEBUG && p != 0) { Log.d(TAG, "Cell radio scanning: time=" + scanningTimeMs + " power=" + formatCharge( diff --git a/core/java/com/android/internal/os/PowerCalculator.java b/core/java/com/android/internal/os/PowerCalculator.java index 72385e273cf0..d139b4f0aa9a 100644 --- a/core/java/com/android/internal/os/PowerCalculator.java +++ b/core/java/com/android/internal/os/PowerCalculator.java @@ -15,6 +15,8 @@ */ package com.android.internal.os; +import android.annotation.NonNull; +import android.os.BatteryConsumer; import android.os.BatteryStats; import android.os.BatteryUsageStats; import android.os.BatteryUsageStatsQuery; @@ -114,19 +116,48 @@ public abstract class PowerCalculator { public void reset() { } + protected static @BatteryConsumer.PowerModel int getPowerModel( + long measuredEnergyUC, @NonNull BatteryUsageStatsQuery query) { + if (measuredEnergyUC != BatteryStats.POWER_DATA_UNAVAILABLE + && !query.shouldForceUsePowerProfileModel()) { + return BatteryConsumer.POWER_MODEL_MEASURED_ENERGY; + } + return BatteryConsumer.POWER_MODEL_POWER_PROFILE; + } + + protected static @BatteryConsumer.PowerModel int getPowerModel(long measuredEnergyUC) { + return measuredEnergyUC != BatteryStats.POWER_DATA_UNAVAILABLE + ? BatteryConsumer.POWER_MODEL_MEASURED_ENERGY + : BatteryConsumer.POWER_MODEL_POWER_PROFILE; + } + /** * Returns either the measured energy converted to mAh or a usage-based estimate. */ - protected static double getMeasuredOrEstimatedPower(long measuredEnergyUC, - UsageBasedPowerEstimator powerEstimator, long durationMs, - boolean forceUsePowerProfileModel) { - if (measuredEnergyUC != BatteryStats.POWER_DATA_UNAVAILABLE - && !forceUsePowerProfileModel) { + protected static double getMeasuredOrEstimatedPower(@BatteryConsumer.PowerModel int powerModel, + long measuredEnergyUC, UsageBasedPowerEstimator powerEstimator, long durationMs) { + switch (powerModel) { + case BatteryConsumer.POWER_MODEL_MEASURED_ENERGY: + return uCtoMah(measuredEnergyUC); + case BatteryConsumer.POWER_MODEL_POWER_PROFILE: + default: + return powerEstimator.calculatePower(durationMs); + } + } + + /** + * Returns either the measured energy converted to mAh or a usage-based estimate. + */ + protected static double getMeasuredOrEstimatedPower( + long measuredEnergyUC, UsageBasedPowerEstimator powerEstimator, long durationMs) { + if (measuredEnergyUC != BatteryStats.POWER_DATA_UNAVAILABLE) { return uCtoMah(measuredEnergyUC); + } else { + return powerEstimator.calculatePower(durationMs); } - return powerEstimator.calculatePower(durationMs); } + /** * Converts charge in mAh to string. */ diff --git a/core/java/com/android/internal/os/ScreenPowerCalculator.java b/core/java/com/android/internal/os/ScreenPowerCalculator.java index ad574440f216..0267def918c2 100644 --- a/core/java/com/android/internal/os/ScreenPowerCalculator.java +++ b/core/java/com/android/internal/os/ScreenPowerCalculator.java @@ -62,9 +62,10 @@ public class ScreenPowerCalculator extends PowerCalculator { long rawRealtimeUs, long rawUptimeUs, BatteryUsageStatsQuery query) { final PowerAndDuration totalPowerAndDuration = new PowerAndDuration(); - final boolean useEnergyData = calculateTotalDurationAndPower(totalPowerAndDuration, - batteryStats, rawRealtimeUs, BatteryStats.STATS_SINCE_CHARGED, - query.shouldForceUsePowerProfileModel()); + final long consumptionUC = batteryStats.getScreenOnMeasuredBatteryConsumptionUC(); + final int powerModel = getPowerModel(consumptionUC, query); + calculateTotalDurationAndPower(totalPowerAndDuration, powerModel, batteryStats, + rawRealtimeUs, BatteryStats.STATS_SINCE_CHARGED, consumptionUC); double totalAppPower = 0; @@ -73,29 +74,32 @@ public class ScreenPowerCalculator extends PowerCalculator { // but the method depends on the data source. final SparseArray<UidBatteryConsumer.Builder> uidBatteryConsumerBuilders = builder.getUidBatteryConsumerBuilders(); - if (useEnergyData) { - final PowerAndDuration appPowerAndDuration = new PowerAndDuration(); - for (int i = uidBatteryConsumerBuilders.size() - 1; i >= 0; i--) { - final UidBatteryConsumer.Builder app = uidBatteryConsumerBuilders.valueAt(i); - calculateAppUsingMeasuredEnergy(appPowerAndDuration, app.getBatteryStatsUid(), + switch (powerModel) { + case BatteryConsumer.POWER_MODEL_MEASURED_ENERGY: + final PowerAndDuration appPowerAndDuration = new PowerAndDuration(); + for (int i = uidBatteryConsumerBuilders.size() - 1; i >= 0; i--) { + final UidBatteryConsumer.Builder app = uidBatteryConsumerBuilders.valueAt(i); + calculateAppUsingMeasuredEnergy(appPowerAndDuration, app.getBatteryStatsUid(), + rawRealtimeUs); + app.setUsageDurationMillis(BatteryConsumer.TIME_COMPONENT_SCREEN, + appPowerAndDuration.durationMs) + .setConsumedPower(BatteryConsumer.POWER_COMPONENT_SCREEN, + appPowerAndDuration.powerMah, powerModel); + totalAppPower += appPowerAndDuration.powerMah; + } + break; + case BatteryConsumer.POWER_MODEL_POWER_PROFILE: + default: + smearScreenBatteryDrain(uidBatteryConsumerBuilders, totalPowerAndDuration, rawRealtimeUs); - app.setUsageDurationMillis(BatteryConsumer.TIME_COMPONENT_SCREEN, - appPowerAndDuration.durationMs) - .setConsumedPower(BatteryConsumer.POWER_COMPONENT_SCREEN, - appPowerAndDuration.powerMah); - totalAppPower += appPowerAndDuration.powerMah; - } - } else { - smearScreenBatteryDrain(uidBatteryConsumerBuilders, totalPowerAndDuration, - rawRealtimeUs); - totalAppPower = totalPowerAndDuration.powerMah; + 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)) + Math.max(totalPowerAndDuration.powerMah, totalAppPower), powerModel) .setPowerConsumedByApps(totalAppPower); } @@ -106,8 +110,10 @@ public class ScreenPowerCalculator extends PowerCalculator { public void calculate(List<BatterySipper> sippers, BatteryStats batteryStats, long rawRealtimeUs, long rawUptimeUs, int statsType, SparseArray<UserHandle> asUsers) { final PowerAndDuration totalPowerAndDuration = new PowerAndDuration(); - final boolean useEnergyData = calculateTotalDurationAndPower(totalPowerAndDuration, - batteryStats, rawRealtimeUs, statsType, false); + final long consumptionUC = batteryStats.getScreenOnMeasuredBatteryConsumptionUC(); + final int powerModel = getPowerModel(consumptionUC); + calculateTotalDurationAndPower(totalPowerAndDuration, powerModel, batteryStats, + rawRealtimeUs, statsType, consumptionUC); if (totalPowerAndDuration.powerMah == 0) { return; } @@ -121,41 +127,42 @@ public class ScreenPowerCalculator extends PowerCalculator { // Now deal with each app's BatterySipper. The results are stored in the screenPowerMah // field, which is considered smeared, but the method depends on the data source. - if (useEnergyData) { - final PowerAndDuration appPowerAndDuration = new PowerAndDuration(); - for (int i = sippers.size() - 1; i >= 0; i--) { - final BatterySipper app = sippers.get(i); - if (app.drainType == BatterySipper.DrainType.APP) { - calculateAppUsingMeasuredEnergy(appPowerAndDuration, app.uidObj, rawRealtimeUs); - app.screenPowerMah = appPowerAndDuration.powerMah; + switch (powerModel) { + case BatteryConsumer.POWER_MODEL_MEASURED_ENERGY: + final PowerAndDuration appPowerAndDuration = new PowerAndDuration(); + for (int i = sippers.size() - 1; i >= 0; i--) { + final BatterySipper app = sippers.get(i); + if (app.drainType == BatterySipper.DrainType.APP) { + calculateAppUsingMeasuredEnergy(appPowerAndDuration, app.uidObj, + rawRealtimeUs); + app.screenPowerMah = appPowerAndDuration.powerMah; + } } - } - } else { - smearScreenBatterySipper(sippers, bs, rawRealtimeUs); + break; + case BatteryConsumer.POWER_MODEL_POWER_PROFILE: + default: + smearScreenBatterySipper(sippers, bs, rawRealtimeUs); } } /** - * Stores duration and power information in totalPowerAndDuration and returns true if measured - * energy data is available and should be used by the model. + * Stores duration and power information in totalPowerAndDuration. */ - private boolean calculateTotalDurationAndPower(PowerAndDuration totalPowerAndDuration, - BatteryStats batteryStats, long rawRealtimeUs, int statsType, - boolean forceUsePowerProfileModel) { + private void calculateTotalDurationAndPower(PowerAndDuration totalPowerAndDuration, + @BatteryConsumer.PowerModel int powerModel, BatteryStats batteryStats, + long rawRealtimeUs, int statsType, long consumptionUC) { totalPowerAndDuration.durationMs = calculateDuration(batteryStats, rawRealtimeUs, statsType); - if (!forceUsePowerProfileModel) { - final long chargeUC = batteryStats.getScreenOnMeasuredBatteryConsumptionUC(); - if (chargeUC != BatteryStats.POWER_DATA_UNAVAILABLE) { - totalPowerAndDuration.powerMah = uCtoMah(chargeUC); - return true; - } + switch (powerModel) { + case BatteryConsumer.POWER_MODEL_MEASURED_ENERGY: + totalPowerAndDuration.powerMah = uCtoMah(consumptionUC); + break; + case BatteryConsumer.POWER_MODEL_POWER_PROFILE: + default: + totalPowerAndDuration.powerMah = calculateTotalPowerFromBrightness(batteryStats, + rawRealtimeUs, statsType, totalPowerAndDuration.durationMs); } - - totalPowerAndDuration.powerMah = calculateTotalPowerFromBrightness(batteryStats, - rawRealtimeUs, statsType, totalPowerAndDuration.durationMs); - return false; } private void calculateAppUsingMeasuredEnergy(PowerAndDuration appPowerAndDuration, @@ -245,7 +252,8 @@ public class ScreenPowerCalculator extends PowerCalculator { final long durationMs = activityTimeArray.get(app.getUid(), 0); final double powerMah = totalScreenPowerMah * durationMs / totalActivityTimeMs; app.setUsageDurationMillis(BatteryConsumer.TIME_COMPONENT_SCREEN, durationMs) - .setConsumedPower(BatteryConsumer.POWER_COMPONENT_SCREEN, powerMah); + .setConsumedPower(BatteryConsumer.POWER_COMPONENT_SCREEN, powerMah, + BatteryConsumer.POWER_MODEL_POWER_PROFILE); } } } diff --git a/core/java/com/android/internal/os/WifiPowerCalculator.java b/core/java/com/android/internal/os/WifiPowerCalculator.java index d95506b00677..11219eccddad 100644 --- a/core/java/com/android/internal/os/WifiPowerCalculator.java +++ b/core/java/com/android/internal/os/WifiPowerCalculator.java @@ -15,8 +15,6 @@ */ package com.android.internal.os; -import static android.os.BatteryStats.POWER_DATA_UNAVAILABLE; - import android.os.BatteryConsumer; import android.os.BatteryStats; import android.os.BatteryUsageStats; @@ -92,10 +90,12 @@ public class WifiPowerCalculator extends PowerCalculator { builder.getUidBatteryConsumerBuilders(); for (int i = uidBatteryConsumerBuilders.size() - 1; i >= 0; i--) { final UidBatteryConsumer.Builder app = uidBatteryConsumerBuilders.valueAt(i); - calculateApp(powerDurationAndTraffic, app.getBatteryStatsUid(), rawRealtimeUs, - BatteryStats.STATS_SINCE_CHARGED, - batteryStats.hasWifiActivityReporting(), - query.shouldForceUsePowerProfileModel()); + final long consumptionUC = + app.getBatteryStatsUid().getWifiMeasuredBatteryConsumptionUC(); + final int powerModel = getPowerModel(consumptionUC, query); + calculateApp(powerDurationAndTraffic, app.getBatteryStatsUid(), powerModel, + rawRealtimeUs, BatteryStats.STATS_SINCE_CHARGED, + batteryStats.hasWifiActivityReporting(), consumptionUC); totalAppDurationMs += powerDurationAndTraffic.durationMs; totalAppPowerMah += powerDurationAndTraffic.powerMah; @@ -103,7 +103,7 @@ public class WifiPowerCalculator extends PowerCalculator { app.setUsageDurationMillis(BatteryConsumer.TIME_COMPONENT_WIFI, powerDurationAndTraffic.durationMs); app.setConsumedPower(BatteryConsumer.POWER_COMPONENT_WIFI, - powerDurationAndTraffic.powerMah); + powerDurationAndTraffic.powerMah, powerModel); if (app.getUid() == Process.WIFI_UID) { systemBatteryConsumerBuilder.addUidBatteryConsumer(app); @@ -111,17 +111,17 @@ public class WifiPowerCalculator extends PowerCalculator { } } - calculateRemaining(powerDurationAndTraffic, batteryStats, rawRealtimeUs, - BatteryStats.STATS_SINCE_CHARGED, - batteryStats.hasWifiActivityReporting(), - query.shouldForceUsePowerProfileModel(), - totalAppDurationMs, totalAppPowerMah); + final long consumptionUC = batteryStats.getWifiMeasuredBatteryConsumptionUC(); + final int powerModel = getPowerModel(consumptionUC, query); + calculateRemaining(powerDurationAndTraffic, powerModel, batteryStats, rawRealtimeUs, + BatteryStats.STATS_SINCE_CHARGED, batteryStats.hasWifiActivityReporting(), + totalAppDurationMs, totalAppPowerMah, consumptionUC); systemBatteryConsumerBuilder .setUsageDurationMillis(BatteryConsumer.TIME_COMPONENT_WIFI, powerDurationAndTraffic.durationMs) .setConsumedPower(BatteryConsumer.POWER_COMPONENT_WIFI, - totalAppPowerMah + powerDurationAndTraffic.powerMah) + totalAppPowerMah + powerDurationAndTraffic.powerMah, powerModel) .setPowerConsumedByApps(totalAppPowerMah); } @@ -144,8 +144,11 @@ public class WifiPowerCalculator extends PowerCalculator { for (int i = sippers.size() - 1; i >= 0; i--) { final BatterySipper app = sippers.get(i); if (app.drainType == BatterySipper.DrainType.APP) { - calculateApp(powerDurationAndTraffic, app.uidObj, rawRealtimeUs, statsType, - batteryStats.hasWifiActivityReporting(), /* force use power model*/ false); + final long consumptionUC = + app.uidObj.getWifiMeasuredBatteryConsumptionUC(); + final int powerModel = getPowerModel(consumptionUC); + calculateApp(powerDurationAndTraffic, app.uidObj, powerModel, rawRealtimeUs, + statsType, batteryStats.hasWifiActivityReporting(), consumptionUC); totalAppDurationMs += powerDurationAndTraffic.durationMs; totalAppPowerMah += powerDurationAndTraffic.powerMah; @@ -164,9 +167,11 @@ public class WifiPowerCalculator extends PowerCalculator { } } - calculateRemaining(powerDurationAndTraffic, batteryStats, rawRealtimeUs, statsType, - batteryStats.hasWifiActivityReporting(), /* force use power model*/ false, - totalAppDurationMs, totalAppPowerMah); + final long consumptionUC = batteryStats.getWifiMeasuredBatteryConsumptionUC(); + final int powerModel = getPowerModel(consumptionUC); + calculateRemaining(powerDurationAndTraffic, powerModel, batteryStats, rawRealtimeUs, + statsType, batteryStats.hasWifiActivityReporting(), totalAppDurationMs, + totalAppPowerMah, consumptionUC); bs.wifiRunningTimeMs += powerDurationAndTraffic.durationMs; bs.wifiPowerMah += powerDurationAndTraffic.powerMah; @@ -176,9 +181,10 @@ public class WifiPowerCalculator extends PowerCalculator { } } - private void calculateApp(PowerDurationAndTraffic powerDurationAndTraffic, BatteryStats.Uid u, - long rawRealtimeUs, int statsType, - boolean hasWifiActivityReporting, boolean shouldForceUsePowerProfileModel) { + private void calculateApp(PowerDurationAndTraffic powerDurationAndTraffic, + BatteryStats.Uid u, @BatteryConsumer.PowerModel int powerModel, + long rawRealtimeUs, int statsType, boolean hasWifiActivityReporting, + long consumptionUC) { powerDurationAndTraffic.wifiRxPackets = u.getNetworkActivityPackets( BatteryStats.NETWORK_WIFI_RX_DATA, @@ -193,11 +199,8 @@ public class WifiPowerCalculator extends PowerCalculator { BatteryStats.NETWORK_WIFI_TX_DATA, statsType); - final long measuredChargeUC = u.getWifiMeasuredBatteryConsumptionUC(); - final boolean isMeasuredPowerAvailable - = !shouldForceUsePowerProfileModel && measuredChargeUC != POWER_DATA_UNAVAILABLE; - if (isMeasuredPowerAvailable) { - powerDurationAndTraffic.powerMah = uCtoMah(measuredChargeUC); + if (powerModel == BatteryConsumer.POWER_MODEL_MEASURED_ENERGY) { + powerDurationAndTraffic.powerMah = uCtoMah(consumptionUC); } if (hasWifiActivityReporting && mHasWifiPowerController) { @@ -208,7 +211,7 @@ public class WifiPowerCalculator extends PowerCalculator { final long rxTime = counter.getRxTimeCounter().getCountLocked(statsType); powerDurationAndTraffic.durationMs = idleTime + rxTime + txTime; - if (!isMeasuredPowerAvailable) { + if (powerModel == BatteryConsumer.POWER_MODEL_POWER_PROFILE) { powerDurationAndTraffic.powerMah = calcPowerFromControllerDataMah(rxTime, txTime, idleTime); } @@ -223,7 +226,7 @@ public class WifiPowerCalculator extends PowerCalculator { final long wifiRunningTime = u.getWifiRunningTime(rawRealtimeUs, statsType) / 1000; powerDurationAndTraffic.durationMs = wifiRunningTime; - if (!isMeasuredPowerAvailable) { + if (powerModel == BatteryConsumer.POWER_MODEL_POWER_PROFILE) { final long wifiScanTimeMs = u.getWifiScanTime(rawRealtimeUs, statsType) / 1000; long batchTimeMs = 0; for (int bin = 0; bin < BatteryStats.Uid.NUM_WIFI_BATCHED_SCAN_BINS; bin++) { @@ -243,19 +246,17 @@ public class WifiPowerCalculator extends PowerCalculator { } private void calculateRemaining(PowerDurationAndTraffic powerDurationAndTraffic, - BatteryStats stats, long rawRealtimeUs, int statsType, - boolean hasWifiActivityReporting, boolean shouldForceUsePowerProfileModel, - long totalAppDurationMs, double totalAppPowerMah) { + @BatteryConsumer.PowerModel int powerModel, BatteryStats stats, long rawRealtimeUs, + int statsType, boolean hasWifiActivityReporting, long totalAppDurationMs, + double totalAppPowerMah, long consumptionUC) { long totalDurationMs; double totalPowerMah = 0; - final long measuredChargeUC = stats.getWifiMeasuredBatteryConsumptionUC(); - final boolean isMeasuredPowerAvailable - = !shouldForceUsePowerProfileModel && measuredChargeUC != POWER_DATA_UNAVAILABLE; - if (isMeasuredPowerAvailable) { - totalPowerMah = uCtoMah(measuredChargeUC); + if (powerModel == BatteryConsumer.POWER_MODEL_MEASURED_ENERGY) { + totalPowerMah = uCtoMah(consumptionUC); } + if (hasWifiActivityReporting && mHasWifiPowerController) { final BatteryStats.ControllerActivityCounter counter = stats.getWifiControllerActivity(); @@ -266,7 +267,7 @@ public class WifiPowerCalculator extends PowerCalculator { totalDurationMs = idleTimeMs + rxTimeMs + txTimeMs; - if (!isMeasuredPowerAvailable) { + if (powerModel == BatteryConsumer.POWER_MODEL_POWER_PROFILE) { totalPowerMah = counter.getPowerCounter().getCountLocked(statsType) / (double) (1000 * 60 * 60); if (totalPowerMah == 0) { @@ -276,7 +277,7 @@ public class WifiPowerCalculator extends PowerCalculator { } } else { totalDurationMs = stats.getGlobalWifiRunningTime(rawRealtimeUs, statsType) / 1000; - if (!isMeasuredPowerAvailable) { + if (powerModel == BatteryConsumer.POWER_MODEL_POWER_PROFILE) { totalPowerMah = calcGlobalPowerWithoutControllerDataMah(totalDurationMs); } } diff --git a/core/tests/coretests/src/com/android/internal/os/AmbientDisplayPowerCalculatorTest.java b/core/tests/coretests/src/com/android/internal/os/AmbientDisplayPowerCalculatorTest.java index c67f90136992..cf47efddddd9 100644 --- a/core/tests/coretests/src/com/android/internal/os/AmbientDisplayPowerCalculatorTest.java +++ b/core/tests/coretests/src/com/android/internal/os/AmbientDisplayPowerCalculatorTest.java @@ -19,7 +19,6 @@ package com.android.internal.os; import static com.google.common.truth.Truth.assertThat; import android.os.BatteryConsumer; -import android.os.BatteryUsageStatsQuery; import android.os.SystemBatteryConsumer; import android.view.Display; @@ -71,6 +70,8 @@ public class AmbientDisplayPowerCalculatorTest { // 100,000,00 uC / 1000 (micro-/milli-) / 360 (seconds/hour) = 27.777778 mAh assertThat(consumer.getConsumedPower(BatteryConsumer.POWER_COMPONENT_USAGE)) .isWithin(PRECISION).of(27.777778); + assertThat(consumer.getPowerModel(BatteryConsumer.POWER_COMPONENT_USAGE)) + .isEqualTo(BatteryConsumer.POWER_MODEL_MEASURED_ENERGY); } @Test @@ -85,8 +86,7 @@ public class AmbientDisplayPowerCalculatorTest { AmbientDisplayPowerCalculator calculator = new AmbientDisplayPowerCalculator(mStatsRule.getPowerProfile()); - mStatsRule.apply(new BatteryUsageStatsQuery.Builder().powerProfileModeledOnly().build(), - calculator); + mStatsRule.apply(BatteryUsageStatsRule.POWER_PROFILE_MODEL_ONLY, calculator); SystemBatteryConsumer consumer = mStatsRule.getSystemBatteryConsumer( @@ -95,5 +95,7 @@ public class AmbientDisplayPowerCalculatorTest { .isEqualTo(90 * MINUTE_IN_MS); assertThat(consumer.getConsumedPower(BatteryConsumer.POWER_COMPONENT_USAGE)) .isWithin(PRECISION).of(15.0); + assertThat(consumer.getPowerModel(BatteryConsumer.POWER_COMPONENT_USAGE)) + .isEqualTo(BatteryConsumer.POWER_MODEL_POWER_PROFILE); } } diff --git a/core/tests/coretests/src/com/android/internal/os/BatteryUsageStatsRule.java b/core/tests/coretests/src/com/android/internal/os/BatteryUsageStatsRule.java index 80ab36ec84cf..1e614c480bde 100644 --- a/core/tests/coretests/src/com/android/internal/os/BatteryUsageStatsRule.java +++ b/core/tests/coretests/src/com/android/internal/os/BatteryUsageStatsRule.java @@ -43,6 +43,12 @@ import org.mockito.stubbing.Answer; import java.util.Arrays; public class BatteryUsageStatsRule implements TestRule { + public static final BatteryUsageStatsQuery POWER_PROFILE_MODEL_ONLY = + new BatteryUsageStatsQuery.Builder() + .powerProfileModeledOnly() + .includePowerModels() + .build(); + private final PowerProfile mPowerProfile; private final MockClocks mMockClocks = new MockClocks(); private final MockBatteryStatsImpl mBatteryStats = new MockBatteryStatsImpl(mMockClocks) { @@ -156,7 +162,8 @@ public class BatteryUsageStatsRule implements TestRule { } BatteryUsageStats apply(PowerCalculator... calculators) { - return apply(BatteryUsageStatsQuery.DEFAULT, calculators); + return apply(new BatteryUsageStatsQuery.Builder().includePowerModels().build(), + calculators); } BatteryUsageStats apply(BatteryUsageStatsQuery query, PowerCalculator... calculators) { @@ -165,8 +172,10 @@ public class BatteryUsageStatsRule implements TestRule { final int customMeasuredEnergiesCount = customMeasuredEnergiesMicroJoules != null ? customMeasuredEnergiesMicroJoules.length : 0; + final boolean includePowerModels = (query.getFlags() + & BatteryUsageStatsQuery.FLAG_BATTERY_USAGE_STATS_INCLUDE_POWER_MODELS) != 0; BatteryUsageStats.Builder builder = new BatteryUsageStats.Builder( - customMeasuredEnergiesCount, 0); + customMeasuredEnergiesCount, 0, includePowerModels); SparseArray<? extends BatteryStats.Uid> uidStats = mBatteryStats.getUidStats(); for (int i = 0; i < uidStats.size(); i++) { builder.getOrCreateUidBatteryConsumerBuilder(uidStats.valueAt(i)); 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 2769b163ecd2..1a87c1084fe0 100644 --- a/core/tests/coretests/src/com/android/internal/os/BluetoothPowerCalculatorTest.java +++ b/core/tests/coretests/src/com/android/internal/os/BluetoothPowerCalculatorTest.java @@ -19,6 +19,8 @@ package com.android.internal.os; import static com.google.common.truth.Truth.assertThat; import android.annotation.Nullable; +import android.bluetooth.BluetoothActivityEnergyInfo; +import android.bluetooth.UidTraffic; import android.os.BatteryConsumer; import android.os.BatteryUsageStatsQuery; import android.os.Process; @@ -41,7 +43,8 @@ public class BluetoothPowerCalculatorTest { public final BatteryUsageStatsRule mStatsRule = new BatteryUsageStatsRule() .setAveragePower(PowerProfile.POWER_BLUETOOTH_CONTROLLER_IDLE, 10.0) .setAveragePower(PowerProfile.POWER_BLUETOOTH_CONTROLLER_RX, 50.0) - .setAveragePower(PowerProfile.POWER_BLUETOOTH_CONTROLLER_TX, 100.0); + .setAveragePower(PowerProfile.POWER_BLUETOOTH_CONTROLLER_TX, 100.0) + .initMeasuredEnergyStatsLocked(0); @Test public void testTimerBasedModel() { @@ -60,16 +63,15 @@ public class BluetoothPowerCalculatorTest { BluetoothPowerCalculator calculator = new BluetoothPowerCalculator(mStatsRule.getPowerProfile()); - mStatsRule.apply(new BatteryUsageStatsQuery.Builder().powerProfileModeledOnly().build(), - calculator); + mStatsRule.apply(BatteryUsageStatsRule.POWER_PROFILE_MODEL_ONLY, calculator); assertThat(mStatsRule.getUidBatteryConsumer(Process.BLUETOOTH_UID)).isNull(); assertBluetoothPowerAndDuration( mStatsRule.getUidBatteryConsumer(APP_UID), - 0.24722, 15000); + 0.24722, 15000, BatteryConsumer.POWER_MODEL_POWER_PROFILE); assertBluetoothPowerAndDuration( mStatsRule.getSystemBatteryConsumer(SystemBatteryConsumer.DRAIN_TYPE_BLUETOOTH), - 0.51944, 9000, 0.51944, 0.36111); + 0.51944, 9000, 0.51944, 0.36111, BatteryConsumer.POWER_MODEL_POWER_PROFILE); } @Test @@ -89,16 +91,40 @@ public class BluetoothPowerCalculatorTest { BluetoothPowerCalculator calculator = new BluetoothPowerCalculator(mStatsRule.getPowerProfile()); - mStatsRule.apply(new BatteryUsageStatsQuery.Builder().powerProfileModeledOnly().build(), + mStatsRule.apply(BatteryUsageStatsRule.POWER_PROFILE_MODEL_ONLY, calculator); + + assertThat(mStatsRule.getUidBatteryConsumer(Process.BLUETOOTH_UID)).isNull(); + assertBluetoothPowerAndDuration( + mStatsRule.getUidBatteryConsumer(APP_UID), + 0.2, 15000, BatteryConsumer.POWER_MODEL_POWER_PROFILE); + assertBluetoothPowerAndDuration( + mStatsRule.getSystemBatteryConsumer(SystemBatteryConsumer.DRAIN_TYPE_BLUETOOTH), + 0.45, 9000, 0.45, 0.3, BatteryConsumer.POWER_MODEL_POWER_PROFILE); + } + + @Test + public void testMeasuredEnergyBasedModel() { + final BluetoothActivityEnergyInfo info = new BluetoothActivityEnergyInfo(1000, + BluetoothActivityEnergyInfo.BT_STACK_STATE_STATE_ACTIVE, 7000, 5000, 0, 100000); + info.setUidTraffic(new UidTraffic[]{ + new UidTraffic(Process.BLUETOOTH_UID, 1000, 2000), + new UidTraffic(APP_UID, 3000, 4000) + }); + mStatsRule.getBatteryStats().updateBluetoothStateLocked(info, 1200000, 1000, 1000); + + final BluetoothPowerCalculator calculator = + new BluetoothPowerCalculator(mStatsRule.getPowerProfile()); + + mStatsRule.apply(new BatteryUsageStatsQuery.Builder().includePowerModels().build(), calculator); assertThat(mStatsRule.getUidBatteryConsumer(Process.BLUETOOTH_UID)).isNull(); assertBluetoothPowerAndDuration( mStatsRule.getUidBatteryConsumer(APP_UID), - 0.2, 15000); + 0.22950, 8416, BatteryConsumer.POWER_MODEL_MEASURED_ENERGY); assertBluetoothPowerAndDuration( mStatsRule.getSystemBatteryConsumer(SystemBatteryConsumer.DRAIN_TYPE_BLUETOOTH), - 0.45, 9000, 0.45, 0.3); + 0.43712, 3584, 0.43712, 0.33329, BatteryConsumer.POWER_MODEL_MEASURED_ENERGY); } private void setDurationsAndPower( @@ -111,12 +137,14 @@ public class BluetoothPowerCalculatorTest { } private void assertBluetoothPowerAndDuration(@Nullable BatteryConsumer batteryConsumer, - double powerMah, int durationMs) { + double powerMah, int durationMs, @BatteryConsumer.PowerModel int powerModel) { assertThat(batteryConsumer).isNotNull(); double consumedPower = batteryConsumer.getConsumedPower( BatteryConsumer.POWER_COMPONENT_BLUETOOTH); assertThat(consumedPower).isWithin(PRECISION).of(powerMah); + assertThat(batteryConsumer.getPowerModel(BatteryConsumer.POWER_COMPONENT_BLUETOOTH)) + .isEqualTo(powerModel); long usageDurationMillis = batteryConsumer.getUsageDurationMillis( BatteryConsumer.TIME_COMPONENT_BLUETOOTH); @@ -125,8 +153,9 @@ public class BluetoothPowerCalculatorTest { } private void assertBluetoothPowerAndDuration(@Nullable SystemBatteryConsumer batteryConsumer, - double powerMah, int durationMs, double consumedPower, double attributedPower) { - assertBluetoothPowerAndDuration(batteryConsumer, powerMah, durationMs); + double powerMah, int durationMs, double consumedPower, double attributedPower, + @BatteryConsumer.PowerModel int powerModel) { + assertBluetoothPowerAndDuration(batteryConsumer, powerMah, durationMs, powerModel); assertThat(batteryConsumer.getConsumedPower()) .isWithin(PRECISION).of(consumedPower); diff --git a/core/tests/coretests/src/com/android/internal/os/CpuPowerCalculatorTest.java b/core/tests/coretests/src/com/android/internal/os/CpuPowerCalculatorTest.java index 496415a43a6a..31abbc20a090 100644 --- a/core/tests/coretests/src/com/android/internal/os/CpuPowerCalculatorTest.java +++ b/core/tests/coretests/src/com/android/internal/os/CpuPowerCalculatorTest.java @@ -26,7 +26,6 @@ import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; import android.os.BatteryConsumer; -import android.os.BatteryUsageStatsQuery; import android.os.Process; import android.os.UidBatteryConsumer; @@ -142,14 +141,15 @@ public class CpuPowerCalculatorTest { CpuPowerCalculator calculator = new CpuPowerCalculator(mStatsRule.getPowerProfile()); - mStatsRule.apply(new BatteryUsageStatsQuery.Builder().powerProfileModeledOnly().build(), - calculator); + mStatsRule.apply(BatteryUsageStatsRule.POWER_PROFILE_MODEL_ONLY, calculator); UidBatteryConsumer uidConsumer1 = mStatsRule.getUidBatteryConsumer(APP_UID1); assertThat(uidConsumer1.getUsageDurationMillis(BatteryConsumer.TIME_COMPONENT_CPU)) .isEqualTo(3333); assertThat(uidConsumer1.getConsumedPower(BatteryConsumer.POWER_COMPONENT_CPU)) .isWithin(PRECISION).of(1.092233); + assertThat(uidConsumer1.getPowerModel(BatteryConsumer.POWER_COMPONENT_CPU)) + .isEqualTo(BatteryConsumer.POWER_MODEL_POWER_PROFILE); assertThat(uidConsumer1.getPackageWithHighestDrain()).isEqualTo("bar"); UidBatteryConsumer uidConsumer2 = mStatsRule.getUidBatteryConsumer(APP_UID2); @@ -157,6 +157,8 @@ public class CpuPowerCalculatorTest { .isEqualTo(7777); assertThat(uidConsumer2.getConsumedPower(BatteryConsumer.POWER_COMPONENT_CPU)) .isWithin(PRECISION).of(2.672322); + assertThat(uidConsumer2.getPowerModel(BatteryConsumer.POWER_COMPONENT_CPU)) + .isEqualTo(BatteryConsumer.POWER_MODEL_POWER_PROFILE); assertThat(uidConsumer2.getPackageWithHighestDrain()).isNull(); } @@ -210,6 +212,8 @@ public class CpuPowerCalculatorTest { .isEqualTo(3333); assertThat(uidConsumer1.getConsumedPower(BatteryConsumer.POWER_COMPONENT_CPU)) .isWithin(PRECISION).of(3.18877); + assertThat(uidConsumer1.getPowerModel(BatteryConsumer.POWER_COMPONENT_CPU)) + .isEqualTo(BatteryConsumer.POWER_MODEL_MEASURED_ENERGY); assertThat(uidConsumer1.getPackageWithHighestDrain()).isEqualTo("bar"); UidBatteryConsumer uidConsumer2 = mStatsRule.getUidBatteryConsumer(APP_UID2); @@ -217,6 +221,8 @@ public class CpuPowerCalculatorTest { .isEqualTo(7777); assertThat(uidConsumer2.getConsumedPower(BatteryConsumer.POWER_COMPONENT_CPU)) .isWithin(PRECISION).of(7.44072); + assertThat(uidConsumer2.getPowerModel(BatteryConsumer.POWER_COMPONENT_CPU)) + .isEqualTo(BatteryConsumer.POWER_MODEL_MEASURED_ENERGY); assertThat(uidConsumer2.getPackageWithHighestDrain()).isNull(); } } diff --git a/core/tests/coretests/src/com/android/internal/os/GnssPowerCalculatorTest.java b/core/tests/coretests/src/com/android/internal/os/GnssPowerCalculatorTest.java index eed61cb0afe7..95c3b4ed8a40 100644 --- a/core/tests/coretests/src/com/android/internal/os/GnssPowerCalculatorTest.java +++ b/core/tests/coretests/src/com/android/internal/os/GnssPowerCalculatorTest.java @@ -19,7 +19,6 @@ package com.android.internal.os; import static com.google.common.truth.Truth.assertThat; import android.os.BatteryConsumer; -import android.os.BatteryUsageStatsQuery; import android.os.Process; import android.os.UidBatteryConsumer; @@ -54,14 +53,15 @@ public class GnssPowerCalculatorTest { GnssPowerCalculator calculator = new GnssPowerCalculator(mStatsRule.getPowerProfile()); - mStatsRule.apply(new BatteryUsageStatsQuery.Builder().powerProfileModeledOnly().build(), - calculator); + mStatsRule.apply(BatteryUsageStatsRule.POWER_PROFILE_MODEL_ONLY, calculator); UidBatteryConsumer consumer = mStatsRule.getUidBatteryConsumer(APP_UID); assertThat(consumer.getUsageDurationMillis(BatteryConsumer.TIME_COMPONENT_GNSS)) .isEqualTo(1000); assertThat(consumer.getConsumedPower(BatteryConsumer.POWER_COMPONENT_GNSS)) .isWithin(PRECISION).of(0.1); + assertThat(consumer.getPowerModel(BatteryConsumer.POWER_COMPONENT_GNSS)) + .isEqualTo(BatteryConsumer.POWER_MODEL_POWER_PROFILE); } @Test @@ -87,11 +87,15 @@ public class GnssPowerCalculatorTest { .isEqualTo(1000); assertThat(consumer.getConsumedPower(BatteryConsumer.POWER_COMPONENT_GNSS)) .isWithin(PRECISION).of(2.77777); + assertThat(consumer.getPowerModel(BatteryConsumer.POWER_COMPONENT_GNSS)) + .isEqualTo(BatteryConsumer.POWER_MODEL_MEASURED_ENERGY); UidBatteryConsumer consumer2 = mStatsRule.getUidBatteryConsumer(APP_UID2); assertThat(consumer2.getUsageDurationMillis(BatteryConsumer.TIME_COMPONENT_GNSS)) .isEqualTo(2000); assertThat(consumer2.getConsumedPower(BatteryConsumer.POWER_COMPONENT_GNSS)) .isWithin(PRECISION).of(5.55555); + assertThat(consumer2.getPowerModel(BatteryConsumer.POWER_COMPONENT_GNSS)) + .isEqualTo(BatteryConsumer.POWER_MODEL_MEASURED_ENERGY); } } 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 813bc9f43662..3505e8c34027 100644 --- a/core/tests/coretests/src/com/android/internal/os/MobileRadioPowerCalculatorTest.java +++ b/core/tests/coretests/src/com/android/internal/os/MobileRadioPowerCalculatorTest.java @@ -26,7 +26,6 @@ import static org.mockito.Mockito.when; import android.net.NetworkCapabilities; import android.net.NetworkStats; import android.os.BatteryConsumer; -import android.os.BatteryUsageStatsQuery; import android.os.Process; import android.os.SystemBatteryConsumer; import android.os.UidBatteryConsumer; @@ -99,13 +98,14 @@ public class MobileRadioPowerCalculatorTest { MobileRadioPowerCalculator calculator = new MobileRadioPowerCalculator(mStatsRule.getPowerProfile()); - mStatsRule.apply(new BatteryUsageStatsQuery.Builder().powerProfileModeledOnly().build(), - calculator); + mStatsRule.apply(BatteryUsageStatsRule.POWER_PROFILE_MODEL_ONLY, calculator); SystemBatteryConsumer consumer = mStatsRule.getSystemBatteryConsumer(SystemBatteryConsumer.DRAIN_TYPE_MOBILE_RADIO); assertThat(consumer.getConsumedPower(BatteryConsumer.POWER_COMPONENT_MOBILE_RADIO)) .isWithin(PRECISION).of(2.2444); + assertThat(consumer.getPowerModel(BatteryConsumer.POWER_COMPONENT_MOBILE_RADIO)) + .isEqualTo(BatteryConsumer.POWER_MODEL_POWER_PROFILE); assertThat(consumer.getConsumedPower()) .isWithin(PRECISION).of(2.2444); assertThat(consumer.getPowerConsumedByApps()) @@ -114,6 +114,8 @@ public class MobileRadioPowerCalculatorTest { UidBatteryConsumer uidConsumer = mStatsRule.getUidBatteryConsumer(APP_UID); assertThat(uidConsumer.getConsumedPower(BatteryConsumer.POWER_COMPONENT_MOBILE_RADIO)) .isWithin(PRECISION).of(0.8); + assertThat(uidConsumer.getPowerModel(BatteryConsumer.POWER_COMPONENT_MOBILE_RADIO)) + .isEqualTo(BatteryConsumer.POWER_MODEL_POWER_PROFILE); } @Test @@ -163,11 +165,15 @@ public class MobileRadioPowerCalculatorTest { // 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(4.31711); + assertThat(consumer.getPowerModel(BatteryConsumer.POWER_COMPONENT_MOBILE_RADIO)) + .isEqualTo(BatteryConsumer.POWER_MODEL_MEASURED_ENERGY); assertThat(consumer.getPowerConsumedByApps()) .isWithin(PRECISION).of(1.53934); UidBatteryConsumer uidConsumer = mStatsRule.getUidBatteryConsumer(APP_UID); assertThat(uidConsumer.getConsumedPower(BatteryConsumer.POWER_COMPONENT_MOBILE_RADIO)) .isWithin(PRECISION).of(1.53934); + assertThat(uidConsumer.getPowerModel(BatteryConsumer.POWER_COMPONENT_MOBILE_RADIO)) + .isEqualTo(BatteryConsumer.POWER_MODEL_MEASURED_ENERGY); } } 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 d296afa00dbc..9cd6ea8a6a3b 100644 --- a/core/tests/coretests/src/com/android/internal/os/ScreenPowerCalculatorTest.java +++ b/core/tests/coretests/src/com/android/internal/os/ScreenPowerCalculatorTest.java @@ -20,7 +20,6 @@ import static com.google.common.truth.Truth.assertThat; import android.app.ActivityManager; import android.os.BatteryConsumer; -import android.os.BatteryUsageStatsQuery; import android.os.Process; import android.os.SystemBatteryConsumer; import android.os.UidBatteryConsumer; @@ -91,6 +90,8 @@ public class ScreenPowerCalculatorTest { // 600000000 uAs * (1 mA / 1000 uA) * (1 h / 3600 s) = 166.66666 mAh assertThat(consumer.getConsumedPower(BatteryConsumer.POWER_COMPONENT_USAGE)) .isWithin(PRECISION).of(166.66666); + assertThat(consumer.getPowerModel(BatteryConsumer.POWER_COMPONENT_USAGE)) + .isEqualTo(BatteryConsumer.POWER_MODEL_MEASURED_ENERGY); assertThat(consumer.getConsumedPower()) .isWithin(PRECISION).of(166.66666); assertThat(consumer.getPowerConsumedByApps()) @@ -105,6 +106,8 @@ public class ScreenPowerCalculatorTest { // Uid1 charge = 200000000 + 5 / 45 * 300000000 mAs = 64.81 mAh assertThat(uid1.getConsumedPower(BatteryConsumer.POWER_COMPONENT_SCREEN)) .isWithin(PRECISION).of(64.81481); + assertThat(uid1.getPowerModel(BatteryConsumer.POWER_COMPONENT_SCREEN)) + .isEqualTo(BatteryConsumer.POWER_MODEL_MEASURED_ENERGY); UidBatteryConsumer uid2 = mStatsRule.getUidBatteryConsumer(APP_UID2); assertThat(uid2.getUsageDurationMillis(BatteryConsumer.TIME_COMPONENT_SCREEN)) @@ -115,6 +118,8 @@ public class ScreenPowerCalculatorTest { // Uid2 charge = 40 / 45 * 300000000 + 100000000 mAs = 101.85 mAh assertThat(uid2.getConsumedPower(BatteryConsumer.POWER_COMPONENT_SCREEN)) .isWithin(PRECISION).of(101.85185); + assertThat(uid2.getPowerModel(BatteryConsumer.POWER_COMPONENT_SCREEN)) + .isEqualTo(BatteryConsumer.POWER_MODEL_MEASURED_ENERGY); } @Test @@ -144,8 +149,7 @@ public class ScreenPowerCalculatorTest { ScreenPowerCalculator calculator = new ScreenPowerCalculator(mStatsRule.getPowerProfile()); - mStatsRule.apply(new BatteryUsageStatsQuery.Builder().powerProfileModeledOnly().build(), - calculator); + mStatsRule.apply(BatteryUsageStatsRule.POWER_PROFILE_MODEL_ONLY, calculator); SystemBatteryConsumer consumer = mStatsRule.getSystemBatteryConsumer(SystemBatteryConsumer.DRAIN_TYPE_SCREEN); @@ -153,6 +157,8 @@ public class ScreenPowerCalculatorTest { .isEqualTo(80 * MINUTE_IN_MS); assertThat(consumer.getConsumedPower(BatteryConsumer.POWER_COMPONENT_USAGE)) .isWithin(PRECISION).of(92.0); + assertThat(consumer.getPowerModel(BatteryConsumer.POWER_COMPONENT_USAGE)) + .isEqualTo(BatteryConsumer.POWER_MODEL_POWER_PROFILE); assertThat(consumer.getConsumedPower()) .isWithin(PRECISION).of(92.0); assertThat(consumer.getPowerConsumedByApps()) @@ -166,6 +172,8 @@ public class ScreenPowerCalculatorTest { // Uid1 charge = 20 / 80 * 92.0 = 23.0 mAh assertThat(uid1.getConsumedPower(BatteryConsumer.POWER_COMPONENT_SCREEN)) .isWithin(PRECISION).of(23.0); + assertThat(uid1.getPowerModel(BatteryConsumer.POWER_COMPONENT_SCREEN)) + .isEqualTo(BatteryConsumer.POWER_MODEL_POWER_PROFILE); UidBatteryConsumer uid2 = mStatsRule.getUidBatteryConsumer(APP_UID2); assertThat(uid2.getUsageDurationMillis(BatteryConsumer.TIME_COMPONENT_SCREEN)) @@ -175,6 +183,8 @@ public class ScreenPowerCalculatorTest { // Uid2 charge = 60 / 80 * 92.0 = 69.0 mAh assertThat(uid2.getConsumedPower(BatteryConsumer.POWER_COMPONENT_SCREEN)) .isWithin(PRECISION).of(69.0); + assertThat(uid2.getPowerModel(BatteryConsumer.POWER_COMPONENT_SCREEN)) + .isEqualTo(BatteryConsumer.POWER_MODEL_POWER_PROFILE); } private void setProcState(int uid, int procState, boolean resumed, long realtimeMs, 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 5df91dd00f59..2e501dbe355e 100644 --- a/core/tests/coretests/src/com/android/internal/os/WifiPowerCalculatorTest.java +++ b/core/tests/coretests/src/com/android/internal/os/WifiPowerCalculatorTest.java @@ -24,7 +24,6 @@ import static com.google.common.truth.Truth.assertThat; import android.net.NetworkCapabilities; import android.net.NetworkStats; import android.os.BatteryConsumer; -import android.os.BatteryUsageStatsQuery; import android.os.Process; import android.os.SystemBatteryConsumer; import android.os.UidBatteryConsumer; @@ -85,14 +84,15 @@ public class WifiPowerCalculatorTest { batteryStats.updateWifiState(energyInfo, POWER_DATA_UNAVAILABLE, 1000, 1000); WifiPowerCalculator calculator = new WifiPowerCalculator(mStatsRule.getPowerProfile()); - mStatsRule.apply(new BatteryUsageStatsQuery.Builder().powerProfileModeledOnly().build(), - calculator); + mStatsRule.apply(BatteryUsageStatsRule.POWER_PROFILE_MODEL_ONLY, calculator); UidBatteryConsumer uidConsumer = mStatsRule.getUidBatteryConsumer(APP_UID); assertThat(uidConsumer.getUsageDurationMillis(BatteryConsumer.TIME_COMPONENT_WIFI)) .isEqualTo(1423); assertThat(uidConsumer.getConsumedPower(BatteryConsumer.POWER_COMPONENT_WIFI)) .isWithin(PRECISION).of(0.2214666); + assertThat(uidConsumer.getPowerModel(BatteryConsumer.POWER_COMPONENT_WIFI)) + .isEqualTo(BatteryConsumer.POWER_MODEL_POWER_PROFILE); SystemBatteryConsumer systemConsumer = mStatsRule.getSystemBatteryConsumer(SystemBatteryConsumer.DRAIN_TYPE_WIFI); @@ -100,6 +100,8 @@ public class WifiPowerCalculatorTest { .isEqualTo(5577); assertThat(systemConsumer.getConsumedPower(BatteryConsumer.POWER_COMPONENT_WIFI)) .isWithin(PRECISION).of(1.11153); + assertThat(systemConsumer.getPowerModel(BatteryConsumer.POWER_COMPONENT_WIFI)) + .isEqualTo(BatteryConsumer.POWER_MODEL_POWER_PROFILE); assertThat(systemConsumer.getPowerConsumedByApps()) .isWithin(PRECISION).of(0.466333); } @@ -120,6 +122,8 @@ public class WifiPowerCalculatorTest { /* Same ratio as in testPowerControllerBasedModel_nonMeasured but scaled by 1_000_000uC. */ assertThat(uidConsumer.getConsumedPower(BatteryConsumer.POWER_COMPONENT_WIFI)) .isWithin(PRECISION).of(0.2214666 / (0.2214666 + 0.645200) * 1_000_000 / 3600000); + assertThat(uidConsumer.getPowerModel(BatteryConsumer.POWER_COMPONENT_WIFI)) + .isEqualTo(BatteryConsumer.POWER_MODEL_MEASURED_ENERGY); SystemBatteryConsumer systemConsumer = mStatsRule.getSystemBatteryConsumer(SystemBatteryConsumer.DRAIN_TYPE_WIFI); @@ -128,6 +132,8 @@ public class WifiPowerCalculatorTest { /* Same ratio as in testPowerControllerBasedModel_nonMeasured but scaled by 1_000_000uC. */ assertThat(systemConsumer.getConsumedPower(BatteryConsumer.POWER_COMPONENT_WIFI)) .isWithin(PRECISION).of(1.11153 / (0.2214666 + 0.645200) * 1_000_000 / 3600000); + assertThat(systemConsumer.getPowerModel(BatteryConsumer.POWER_COMPONENT_WIFI)) + .isEqualTo(BatteryConsumer.POWER_MODEL_MEASURED_ENERGY); assertThat(systemConsumer.getPowerConsumedByApps()) .isWithin(PRECISION).of(0.14946); } @@ -153,14 +159,15 @@ public class WifiPowerCalculatorTest { batteryStats.updateWifiState(/* energyInfo */ null, POWER_DATA_UNAVAILABLE, 1000, 1000); WifiPowerCalculator calculator = new WifiPowerCalculator(mStatsRule.getPowerProfile()); - mStatsRule.apply(new BatteryUsageStatsQuery.Builder().powerProfileModeledOnly().build(), - calculator); + mStatsRule.apply(BatteryUsageStatsRule.POWER_PROFILE_MODEL_ONLY, calculator); UidBatteryConsumer uidConsumer = mStatsRule.getUidBatteryConsumer(APP_UID); assertThat(uidConsumer.getUsageDurationMillis(BatteryConsumer.TIME_COMPONENT_WIFI)) .isEqualTo(1000); assertThat(uidConsumer.getConsumedPower(BatteryConsumer.POWER_COMPONENT_WIFI)) .isWithin(PRECISION).of(0.8231573); + assertThat(uidConsumer.getPowerModel(BatteryConsumer.POWER_COMPONENT_WIFI)) + .isEqualTo(BatteryConsumer.POWER_MODEL_POWER_PROFILE); SystemBatteryConsumer systemConsumer = mStatsRule.getSystemBatteryConsumer(SystemBatteryConsumer.DRAIN_TYPE_WIFI); @@ -168,6 +175,8 @@ public class WifiPowerCalculatorTest { .isEqualTo(2222); assertThat(systemConsumer.getConsumedPower(BatteryConsumer.POWER_COMPONENT_WIFI)) .isWithin(PRECISION).of(2.575000); + assertThat(systemConsumer.getPowerModel(BatteryConsumer.POWER_COMPONENT_WIFI)) + .isEqualTo(BatteryConsumer.POWER_MODEL_POWER_PROFILE); assertThat(systemConsumer.getPowerConsumedByApps()) .isWithin(PRECISION).of(1.69907); } @@ -189,6 +198,8 @@ public class WifiPowerCalculatorTest { /* Same ratio as in testTimerBasedModel_nonMeasured but scaled by 1_000_000uC. */ assertThat(uidConsumer.getConsumedPower(BatteryConsumer.POWER_COMPONENT_WIFI)) .isWithin(PRECISION).of(0.8231573 / (0.8231573 + 0.8759216) * 1_000_000 / 3600000); + assertThat(uidConsumer.getPowerModel(BatteryConsumer.POWER_COMPONENT_WIFI)) + .isEqualTo(BatteryConsumer.POWER_MODEL_MEASURED_ENERGY); SystemBatteryConsumer systemConsumer = mStatsRule.getSystemBatteryConsumer(SystemBatteryConsumer.DRAIN_TYPE_WIFI); @@ -197,6 +208,8 @@ public class WifiPowerCalculatorTest { /* Same ratio as in testTimerBasedModel_nonMeasured but scaled by 1_000_000uC. */ assertThat(systemConsumer.getConsumedPower(BatteryConsumer.POWER_COMPONENT_WIFI)) .isWithin(PRECISION).of(2.575000 / (0.8231573 + 0.8759216) * 1_000_000 / 3600000); + assertThat(systemConsumer.getPowerModel(BatteryConsumer.POWER_COMPONENT_WIFI)) + .isEqualTo(BatteryConsumer.POWER_MODEL_MEASURED_ENERGY); assertThat(systemConsumer.getPowerConsumedByApps()) .isWithin(PRECISION).of(0.277777); } |