Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add BatteryConsumer.getPowerModel() method

Browse Source 
This method will be used for testing and visualization purposes.

Bug: 184207674
Test: atest FrameworksCoreTests:com.android.internal.os.BatteryStatsTests
Change-Id: Id28ba4cbb8f27774f36248678f93ec187bc022b3
This commit is contained in:
Dmitri Plotnikov
2021-03-31 17:56:13 -07:00
parent 68037c9a26
commit c13f44e0aa
24 changed files with 482 additions and 234 deletions
Download Patch File Download Diff File Expand all files Collapse all files

56
core/java/android/os/BatteryConsumer.java
View File

@@ -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) {
@@ -148,6 +172,16 @@ public abstract class BatteryConsumer {
return mPowerComponents.getConsumedPower(componentId);
}
/**
* 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.
*
@@ -188,9 +222,22 @@ 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);
}
/**
* 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.
*/
@NonNull
public T setConsumedPower(@PowerComponent int componentId, double componentPower) {
return setConsumedPower(componentId, componentPower, POWER_MODEL_POWER_PROFILE);
}
/**
@@ -202,8 +249,9 @@ public abstract class BatteryConsumer {
*/
@SuppressWarnings("unchecked")
@NonNull
public T setConsumedPower(@PowerComponent int componentId, double componentPower) {
mPowerComponentsBuilder.setConsumedPower(componentId, componentPower);
public T setConsumedPower(@PowerComponent int componentId, double componentPower,
@PowerModel int powerModel) {
mPowerComponentsBuilder.setConsumedPower(componentId, componentPower, powerModel);
return (T) this;
}

13
core/java/android/os/BatteryUsageStats.java
View File

@@ -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;

17
core/java/android/os/BatteryUsageStatsQuery.java
View File

@@ -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;
@@ -186,6 +192,17 @@ public final class BatteryUsageStatsQuery implements Parcelable {
return this;
}
/**
* 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.

37
core/java/android/os/PowerComponents.java
View File

@@ -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;
}

4
core/java/android/os/SystemBatteryConsumer.java
View File

@@ -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;
}

4
core/java/android/os/UidBatteryConsumer.java
View File

@@ -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();
}

5
core/java/android/os/UserBatteryConsumer.java
View File

@@ -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;
}

15
core/java/com/android/internal/os/AmbientDisplayPowerCalculator.java
View File

@@ -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;

9
core/java/com/android/internal/os/BatteryUsageStatsProvider.java
View File

@@ -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--) {

33
core/java/com/android/internal/os/BluetoothPowerCalculator.java
View File

@@ -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;
}

30
core/java/com/android/internal/os/CpuPowerCalculator.java
View File

@@ -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)) {

56
core/java/com/android/internal/os/GnssPowerCalculator.java
View File

@@ -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;

68
core/java/com/android/internal/os/MobileRadioPowerCalculator.java
View File

@@ -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(

45
core/java/com/android/internal/os/PowerCalculator.java
View File

@@ -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) {
return uCtoMah(measuredEnergyUC);
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);
}
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);
}
}
/**
* Converts charge in mAh to string.
*/

102
core/java/com/android/internal/os/ScreenPowerCalculator.java
View File

@@ -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);
}
}
}

77
core/java/com/android/internal/os/WifiPowerCalculator.java
View File

@@ -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);
}
}

8
core/tests/coretests/src/com/android/internal/os/AmbientDisplayPowerCalculatorTest.java
View File

@@ -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);
}
}

13
core/tests/coretests/src/com/android/internal/os/BatteryUsageStatsRule.java
View File

@@ -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));

51
core/tests/coretests/src/com/android/internal/os/BluetoothPowerCalculatorTest.java
View File

@@ -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);

12
core/tests/coretests/src/com/android/internal/os/CpuPowerCalculatorTest.java
View File

@@ -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();
}
}

10
core/tests/coretests/src/com/android/internal/os/GnssPowerCalculatorTest.java
View File

@@ -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);
}
}

12
core/tests/coretests/src/com/android/internal/os/MobileRadioPowerCalculatorTest.java
View File

@@ -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);
}
}

16
core/tests/coretests/src/com/android/internal/os/ScreenPowerCalculatorTest.java
View File

@@ -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,

23
core/tests/coretests/src/com/android/internal/os/WifiPowerCalculatorTest.java
View File

@@ -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);
}