Merge changes I504d9c65,I45abcf87 into sc-v2-dev am: 8baec90550 (09c1d2fa) · Commits · e / os / android_frameworks_base

core/java/com/android/internal/os/AmbientDisplayPowerCalculator.java

+33 −9

Original line number	Diff line number	Diff line
		@@ -31,12 +31,15 @@ import java.util.List;
		* Estimates power consumed by the ambient display
		*/
		public class AmbientDisplayPowerCalculator extends PowerCalculator {
		private final UsageBasedPowerEstimator mPowerEstimator;
		private final UsageBasedPowerEstimator[] mPowerEstimators;

		public AmbientDisplayPowerCalculator(PowerProfile powerProfile) {
		// TODO(b/200239964): update to support multidisplay.
		mPowerEstimator = new UsageBasedPowerEstimator(
		powerProfile.getAveragePowerForOrdinal(POWER_GROUP_DISPLAY_AMBIENT, 0));
		final int numDisplays = powerProfile.getNumDisplays();
		mPowerEstimators = new UsageBasedPowerEstimator[numDisplays];
		for (int display = 0; display < numDisplays; display++) {
		mPowerEstimators[display] = new UsageBasedPowerEstimator(
		powerProfile.getAveragePowerForOrdinal(POWER_GROUP_DISPLAY_AMBIENT, display));
		}
		}

		/**
		@@ -50,8 +53,8 @@ public class AmbientDisplayPowerCalculator extends PowerCalculator {
		final int powerModel = getPowerModel(measuredEnergyUC, query);
		final long durationMs = calculateDuration(batteryStats, rawRealtimeUs,
		BatteryStats.STATS_SINCE_CHARGED);
		final double powerMah = getMeasuredOrEstimatedPower(powerModel,
		measuredEnergyUC, mPowerEstimator, durationMs);
		final double powerMah = calculateTotalPower(powerModel, batteryStats, rawRealtimeUs,
		measuredEnergyUC);
		builder.getAggregateBatteryConsumerBuilder(
		BatteryUsageStats.AGGREGATE_BATTERY_CONSUMER_SCOPE_DEVICE)
		.setUsageDurationMillis(BatteryConsumer.POWER_COMPONENT_AMBIENT_DISPLAY, durationMs)
		@@ -71,9 +74,8 @@ public class AmbientDisplayPowerCalculator extends PowerCalculator {
		final long measuredEnergyUC = batteryStats.getScreenDozeMeasuredBatteryConsumptionUC();
		final long durationMs = calculateDuration(batteryStats, rawRealtimeUs, statsType);
		final int powerModel = getPowerModel(measuredEnergyUC);
		final double powerMah = getMeasuredOrEstimatedPower(powerModel,
		batteryStats.getScreenDozeMeasuredBatteryConsumptionUC(),
		mPowerEstimator, durationMs);
		final double powerMah = calculateTotalPower(powerModel, batteryStats, rawRealtimeUs,
		measuredEnergyUC);
		if (powerMah > 0) {
		BatterySipper bs = new BatterySipper(BatterySipper.DrainType.AMBIENT_DISPLAY, null, 0);
		bs.usagePowerMah = powerMah;
		@@ -86,4 +88,26 @@ public class AmbientDisplayPowerCalculator extends PowerCalculator {
		private long calculateDuration(BatteryStats batteryStats, long rawRealtimeUs, int statsType) {
		return batteryStats.getScreenDozeTime(rawRealtimeUs, statsType) / 1000;
		}

		private double calculateTotalPower(@BatteryConsumer.PowerModel int powerModel,
		BatteryStats batteryStats, long rawRealtimeUs, long consumptionUC) {
		switch (powerModel) {
		case BatteryConsumer.POWER_MODEL_MEASURED_ENERGY:
		return uCtoMah(consumptionUC);
		case BatteryConsumer.POWER_MODEL_POWER_PROFILE:
		default:
		return calculateEstimatedPower(batteryStats, rawRealtimeUs);
		}
		}

		private double calculateEstimatedPower(BatteryStats batteryStats, long rawRealtimeUs) {
		final int numDisplays = mPowerEstimators.length;
		double power = 0;
		for (int display = 0; display < numDisplays; display++) {
		final long dozeTime = batteryStats.getDisplayScreenDozeTime(display, rawRealtimeUs)
		/ 1000;
		power += mPowerEstimators[display].calculatePower(dozeTime);
		}
		return power;
		}
		}

core/java/com/android/internal/os/BatteryStatsImpl.java

+61 −15

Original line number	Diff line number	Diff line
		@@ -903,6 +903,11 @@ public class BatteryStatsImpl extends BatteryStats {
		*/
		public StopwatchTimer[] screenBrightnessTimers =
		new StopwatchTimer[NUM_SCREEN_BRIGHTNESS_BINS];
		/**
		* Per display screen state the last time {@link #updateDisplayMeasuredEnergyStatsLocked}
		* was called.
		*/
		public int screenStateAtLastEnergyMeasurement = Display.STATE_UNKNOWN;

		DisplayBatteryStats(Clocks clocks, TimeBase timeBase) {
		screenOnTimer = new StopwatchTimer(clocks, null, -1, null,
		@@ -929,6 +934,8 @@ public class BatteryStatsImpl extends BatteryStats {

		DisplayBatteryStats[] mPerDisplayBatteryStats;

		private int mDisplayMismatchWtfCount = 0;

		boolean mInteractive;
		StopwatchTimer mInteractiveTimer;

		@@ -1073,8 +1080,6 @@ public class BatteryStatsImpl extends BatteryStats {
		@GuardedBy("this")
		@VisibleForTesting
		protected @Nullable MeasuredEnergyStats mGlobalMeasuredEnergyStats;
		/** Last known screen state. Needed for apportioning display energy. */
		int mScreenStateAtLastEnergyMeasurement = Display.STATE_UNKNOWN;
		/** Bluetooth Power calculator for attributing measured bluetooth charge consumption to uids */
		@Nullable BluetoothPowerCalculator mBluetoothPowerCalculator = null;
		/** Cpu Power calculator for attributing measured cpu charge consumption to uids */
		@@ -12924,22 +12929,43 @@ public class BatteryStatsImpl extends BatteryStats {
		* is always 0 when the screen is not "ON" and whenever the rail energy is 0 (if supported).
		* To the extent that those assumptions are violated, the algorithm will err.
		*
		* @param chargeUC amount of charge (microcoulombs) used by Display since this was last called.
		* @param screenState screen state at the time this data collection was scheduled
		* @param chargesUC amount of charge (microcoulombs) used by each Display since this was last
		* called.
		* @param screenStates each screen state at the time this data collection was scheduled
		*/
		@GuardedBy("this")
		public void updateDisplayMeasuredEnergyStatsLocked(long chargeUC, int screenState,
		public void updateDisplayMeasuredEnergyStatsLocked(long[] chargesUC, int[] screenStates,
		long elapsedRealtimeMs) {
		if (DEBUG_ENERGY) Slog.d(TAG, "Updating display stats: " + chargeUC);
		if (DEBUG_ENERGY) Slog.d(TAG, "Updating display stats: " + Arrays.toString(chargesUC));
		if (mGlobalMeasuredEnergyStats == null) {
		return;
		}

		final @StandardPowerBucket int powerBucket =
		MeasuredEnergyStats.getDisplayPowerBucket(mScreenStateAtLastEnergyMeasurement);
		mScreenStateAtLastEnergyMeasurement = screenState;
		final int numDisplays;
		if (mPerDisplayBatteryStats.length == screenStates.length) {
		numDisplays = screenStates.length;
		} else {
		// if this point is reached, it will be reached every display state change.
		// Rate limit the wtf logging to once every 100 display updates.
		if (mDisplayMismatchWtfCount++ % 100 == 0) {
		Slog.wtf(TAG, "Mismatch between PowerProfile reported display count ("
		+ mPerDisplayBatteryStats.length
		+ ") and PowerStatsHal reported display count (" + screenStates.length
		+ ")");
		}
		// Keep the show going, use the shorter of the two.
		numDisplays = mPerDisplayBatteryStats.length < screenStates.length
		? mPerDisplayBatteryStats.length : screenStates.length;
		}

		if (!mOnBatteryInternal \|\| chargeUC <= 0) {
		final int[] oldScreenStates = new int[numDisplays];
		for (int i = 0; i < numDisplays; i++) {
		final int screenState = screenStates[i];
		oldScreenStates[i] = mPerDisplayBatteryStats[i].screenStateAtLastEnergyMeasurement;
		mPerDisplayBatteryStats[i].screenStateAtLastEnergyMeasurement = screenState;
		}

		if (!mOnBatteryInternal) {
		// There's nothing further to update.
		return;
		}
		@@ -12954,17 +12980,31 @@ public class BatteryStatsImpl extends BatteryStats {
		return;
		}

		long totalScreenOnChargeUC = 0;
		for (int i = 0; i < numDisplays; i++) {
		final long chargeUC = chargesUC[i];
		if (chargeUC <= 0) {
		// There's nothing further to update.
		continue;
		}

		final @StandardPowerBucket int powerBucket =
		MeasuredEnergyStats.getDisplayPowerBucket(oldScreenStates[i]);
		mGlobalMeasuredEnergyStats.updateStandardBucket(powerBucket, chargeUC);
		if (powerBucket == MeasuredEnergyStats.POWER_BUCKET_SCREEN_ON) {
		totalScreenOnChargeUC += chargeUC;
		}
		}

		// Now we blame individual apps, but only if the display was ON.
		if (powerBucket != MeasuredEnergyStats.POWER_BUCKET_SCREEN_ON) {
		if (totalScreenOnChargeUC <= 0) {
		return;
		}
		// TODO(b/175726779): Consider unifying the code with the non-rail display power blaming.

		// NOTE: fg time is NOT pooled. If two uids are both somehow in fg, then that time is
		// 'double counted' and will simply exceed the realtime that elapsed.
		// If multidisplay becomes a reality, this is probably more reasonable than pooling.
		// TODO(b/175726779): collect per display uid visibility for display power attribution.

		// Collect total time since mark so that we can normalize power.
		final SparseDoubleArray fgTimeUsArray = new SparseDoubleArray();
		@@ -12977,7 +13017,8 @@ public class BatteryStatsImpl extends BatteryStats {
		if (fgTimeUs == 0) continue;
		fgTimeUsArray.put(uid.getUid(), (double) fgTimeUs);
		}
		distributeEnergyToUidsLocked(powerBucket, chargeUC, fgTimeUsArray, 0);
		distributeEnergyToUidsLocked(MeasuredEnergyStats.POWER_BUCKET_SCREEN_ON,
		totalScreenOnChargeUC, fgTimeUsArray, 0);
		}

		/**
		@@ -14883,7 +14924,12 @@ public class BatteryStatsImpl extends BatteryStats {
		public void initMeasuredEnergyStatsLocked(@Nullable boolean[] supportedStandardBuckets,
		String[] customBucketNames) {
		boolean supportedBucketMismatch = false;
		mScreenStateAtLastEnergyMeasurement = mScreenState;

		final int numDisplays = mPerDisplayBatteryStats.length;
		for (int i = 0; i < numDisplays; i++) {
		final int screenState = mPerDisplayBatteryStats[i].screenState;
		mPerDisplayBatteryStats[i].screenStateAtLastEnergyMeasurement = screenState;
		}

		if (supportedStandardBuckets == null) {
		if (mGlobalMeasuredEnergyStats != null) {

core/java/com/android/internal/os/PowerCalculator.java

+0 −26

Original line number	Diff line number	Diff line
		@@ -132,32 +132,6 @@ public abstract class PowerCalculator {
		: BatteryConsumer.POWER_MODEL_POWER_PROFILE;
		}

		/**
		* Returns either the measured energy converted to mAh or a usage-based estimate.
		*/
		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);
		}
		}

		/**
		* Prints formatted amount of power in milli-amp-hours.
		*/

core/java/com/android/internal/os/ScreenPowerCalculator.java

+31 −20

Original line number	Diff line number	Diff line
		@@ -44,8 +44,8 @@ public class ScreenPowerCalculator extends PowerCalculator {
		// Minimum amount of time the screen should be on to start smearing drain to apps
		public static final long MIN_ACTIVE_TIME_FOR_SMEARING = 10 * DateUtils.MINUTE_IN_MILLIS;

		private final UsageBasedPowerEstimator mScreenOnPowerEstimator;
		private final UsageBasedPowerEstimator mScreenFullPowerEstimator;
		private final UsageBasedPowerEstimator[] mScreenOnPowerEstimators;
		private final UsageBasedPowerEstimator[] mScreenFullPowerEstimators;

		private static class PowerAndDuration {
		public long durationMs;
		@@ -53,11 +53,16 @@ public class ScreenPowerCalculator extends PowerCalculator {
		}

		public ScreenPowerCalculator(PowerProfile powerProfile) {
		// TODO(b/200239964): update to support multidisplay.
		mScreenOnPowerEstimator = new UsageBasedPowerEstimator(
		powerProfile.getAveragePowerForOrdinal(POWER_GROUP_DISPLAY_SCREEN_ON, 0));
		mScreenFullPowerEstimator = new UsageBasedPowerEstimator(
		powerProfile.getAveragePowerForOrdinal(POWER_GROUP_DISPLAY_SCREEN_FULL, 0));
		final int numDisplays = powerProfile.getNumDisplays();
		mScreenOnPowerEstimators = new UsageBasedPowerEstimator[numDisplays];
		mScreenFullPowerEstimators = new UsageBasedPowerEstimator[numDisplays];
		for (int display = 0; display < numDisplays; display++) {
		mScreenOnPowerEstimators[display] = new UsageBasedPowerEstimator(
		powerProfile.getAveragePowerForOrdinal(POWER_GROUP_DISPLAY_SCREEN_ON, display));
		mScreenFullPowerEstimators[display] = new UsageBasedPowerEstimator(
		powerProfile.getAveragePowerForOrdinal(POWER_GROUP_DISPLAY_SCREEN_FULL,
		display));
		}
		}

		@Override
		@@ -172,7 +177,7 @@ public class ScreenPowerCalculator extends PowerCalculator {
		case BatteryConsumer.POWER_MODEL_POWER_PROFILE:
		default:
		totalPowerAndDuration.powerMah = calculateTotalPowerFromBrightness(batteryStats,
		rawRealtimeUs, statsType, totalPowerAndDuration.durationMs);
		rawRealtimeUs);
		}
		}

		@@ -194,20 +199,26 @@ public class ScreenPowerCalculator extends PowerCalculator {
		return batteryStats.getScreenOnTime(rawRealtimeUs, statsType) / 1000;
		}

		private double calculateTotalPowerFromBrightness(BatteryStats batteryStats, long rawRealtimeUs,
		int statsType, long durationMs) {
		double power = mScreenOnPowerEstimator.calculatePower(durationMs);
		for (int i = 0; i < BatteryStats.NUM_SCREEN_BRIGHTNESS_BINS; i++) {
		final long brightnessTime =
		batteryStats.getScreenBrightnessTime(i, rawRealtimeUs, statsType) / 1000;
		final double binPowerMah = mScreenFullPowerEstimator.calculatePower(brightnessTime)
		* (i + 0.5f) / BatteryStats.NUM_SCREEN_BRIGHTNESS_BINS;
		private double calculateTotalPowerFromBrightness(BatteryStats batteryStats,
		long rawRealtimeUs) {
		final int numDisplays = mScreenOnPowerEstimators.length;
		double power = 0;
		for (int display = 0; display < numDisplays; display++) {
		final long displayTime = batteryStats.getDisplayScreenOnTime(display, rawRealtimeUs)
		/ 1000;
		power += mScreenOnPowerEstimators[display].calculatePower(displayTime);
		for (int bin = 0; bin < BatteryStats.NUM_SCREEN_BRIGHTNESS_BINS; bin++) {
		final long brightnessTime = batteryStats.getDisplayScreenBrightnessTime(display,
		bin, rawRealtimeUs) / 1000;
		final double binPowerMah = mScreenFullPowerEstimators[display].calculatePower(
		brightnessTime) * (bin + 0.5f) / BatteryStats.NUM_SCREEN_BRIGHTNESS_BINS;
		if (DEBUG && binPowerMah != 0) {
		Slog.d(TAG, "Screen bin #" + i + ": time=" + brightnessTime
		Slog.d(TAG, "Screen bin #" + bin + ": time=" + brightnessTime
		+ " power=" + formatCharge(binPowerMah));
		}
		power += binPowerMah;
		}
		}
		return power;
		}

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

+101 −6

Original line number	Diff line number	Diff line
		@@ -38,26 +38,28 @@ public class AmbientDisplayPowerCalculatorTest {

		@Rule
		public final BatteryUsageStatsRule mStatsRule = new BatteryUsageStatsRule()
		.setAveragePowerForOrdinal(POWER_GROUP_DISPLAY_AMBIENT, 0, 10.0);
		.setAveragePowerForOrdinal(POWER_GROUP_DISPLAY_AMBIENT, 0, 10.0)
		.setNumDisplays(1);

		@Test
		public void testMeasuredEnergyBasedModel() {
		mStatsRule.initMeasuredEnergyStatsLocked();
		BatteryStatsImpl stats = mStatsRule.getBatteryStats();

		stats.updateDisplayMeasuredEnergyStatsLocked(300_000_000, Display.STATE_ON, 0);
		stats.updateDisplayMeasuredEnergyStatsLocked(new long[]{300_000_000},
		new int[]{Display.STATE_ON}, 0);

		stats.noteScreenStateLocked(0, Display.STATE_DOZE, 30 * MINUTE_IN_MS, 30 * MINUTE_IN_MS,
		30 * MINUTE_IN_MS);

		stats.updateDisplayMeasuredEnergyStatsLocked(200_000_000, Display.STATE_DOZE,
		30 * MINUTE_IN_MS);
		stats.updateDisplayMeasuredEnergyStatsLocked(new long[]{200_000_000},
		new int[]{Display.STATE_DOZE}, 30 * MINUTE_IN_MS);

		stats.noteScreenStateLocked(0, Display.STATE_OFF, 120 * MINUTE_IN_MS, 120 * MINUTE_IN_MS,
		120 * MINUTE_IN_MS);

		stats.updateDisplayMeasuredEnergyStatsLocked(100_000_000, Display.STATE_OFF,
		120 * MINUTE_IN_MS);
		stats.updateDisplayMeasuredEnergyStatsLocked(new long[]{100_000_000},
		new int[]{Display.STATE_OFF}, 120 * MINUTE_IN_MS);

		AmbientDisplayPowerCalculator calculator =
		new AmbientDisplayPowerCalculator(mStatsRule.getPowerProfile());
		@@ -74,6 +76,67 @@ public class AmbientDisplayPowerCalculatorTest {
		.isEqualTo(BatteryConsumer.POWER_MODEL_MEASURED_ENERGY);
		}

		@Test
		public void testMeasuredEnergyBasedModel_multiDisplay() {
		mStatsRule.initMeasuredEnergyStatsLocked()
		.setAveragePowerForOrdinal(POWER_GROUP_DISPLAY_AMBIENT, 1, 20.0)
		.setNumDisplays(2);
		BatteryStatsImpl stats = mStatsRule.getBatteryStats();


		final int[] screenStates = new int[] {Display.STATE_OFF, Display.STATE_OFF};

		stats.noteScreenStateLocked(0, screenStates[0], 0, 0, 0);
		stats.noteScreenStateLocked(1, screenStates[1], 0, 0, 0);
		stats.updateDisplayMeasuredEnergyStatsLocked(new long[]{300, 400}, screenStates, 0);

		// Switch display0 to doze
		screenStates[0] = Display.STATE_DOZE;
		stats.noteScreenStateLocked(0, screenStates[0], 30 * MINUTE_IN_MS, 30 * MINUTE_IN_MS,
		30 * MINUTE_IN_MS);
		stats.updateDisplayMeasuredEnergyStatsLocked(new long[]{200, 300},
		screenStates, 30 * MINUTE_IN_MS);

		// Switch display1 to doze
		screenStates[1] = Display.STATE_DOZE;
		stats.noteScreenStateLocked(1, Display.STATE_DOZE, 90 * MINUTE_IN_MS, 90 * MINUTE_IN_MS,
		90 * MINUTE_IN_MS);
		// 100,000,000 uC should be attributed to display 0 doze here.
		stats.updateDisplayMeasuredEnergyStatsLocked(new long[]{100_000_000, 700_000_000},
		screenStates, 90 * MINUTE_IN_MS);

		// Switch display0 to off
		screenStates[0] = Display.STATE_OFF;
		stats.noteScreenStateLocked(0, screenStates[0], 120 * MINUTE_IN_MS, 120 * MINUTE_IN_MS,
		120 * MINUTE_IN_MS);
		// 40,000,000 and 70,000,000 uC should be attributed to display 0 and 1 doze here.
		stats.updateDisplayMeasuredEnergyStatsLocked(new long[]{40_000_000, 70_000_000},
		screenStates, 120 * MINUTE_IN_MS);

		// Switch display1 to off
		screenStates[1] = Display.STATE_OFF;
		stats.noteScreenStateLocked(1, screenStates[1], 150 * MINUTE_IN_MS, 150 * MINUTE_IN_MS,
		150 * MINUTE_IN_MS);
		stats.updateDisplayMeasuredEnergyStatsLocked(new long[]{100, 90_000_000}, screenStates,
		150 * MINUTE_IN_MS);
		// 90,000,000 uC should be attributed to display 1 doze here.

		AmbientDisplayPowerCalculator calculator =
		new AmbientDisplayPowerCalculator(mStatsRule.getPowerProfile());

		mStatsRule.apply(calculator);

		BatteryConsumer consumer = mStatsRule.getDeviceBatteryConsumer();
		assertThat(consumer.getUsageDurationMillis(BatteryConsumer.POWER_COMPONENT_AMBIENT_DISPLAY))
		.isEqualTo(120 * MINUTE_IN_MS);
		// 100,000,000 + 40,000,000 + 70,000,000 + 90,000,000 uC / 1000 (micro-/milli-) / 3600
		// (seconds/hour) = 27.777778 mAh
		assertThat(consumer.getConsumedPower(BatteryConsumer.POWER_COMPONENT_AMBIENT_DISPLAY))
		.isWithin(PRECISION).of(83.33333);
		assertThat(consumer.getPowerModel(BatteryConsumer.POWER_COMPONENT_AMBIENT_DISPLAY))
		.isEqualTo(BatteryConsumer.POWER_MODEL_MEASURED_ENERGY);
		}

		@Test
		public void testPowerProfileBasedModel() {
		BatteryStatsImpl stats = mStatsRule.getBatteryStats();
		@@ -96,4 +159,36 @@ public class AmbientDisplayPowerCalculatorTest {
		assertThat(consumer.getPowerModel(BatteryConsumer.POWER_COMPONENT_AMBIENT_DISPLAY))
		.isEqualTo(BatteryConsumer.POWER_MODEL_POWER_PROFILE);
		}

		@Test
		public void testPowerProfileBasedModel_multiDisplay() {
		mStatsRule.setAveragePowerForOrdinal(POWER_GROUP_DISPLAY_AMBIENT, 1, 20.0)
		.setNumDisplays(2);

		BatteryStatsImpl stats = mStatsRule.getBatteryStats();

		stats.noteScreenStateLocked(1, Display.STATE_OFF, 0, 0, 0);
		stats.noteScreenStateLocked(0, Display.STATE_DOZE, 30 * MINUTE_IN_MS, 30 * MINUTE_IN_MS,
		30 * MINUTE_IN_MS);
		stats.noteScreenStateLocked(1, Display.STATE_DOZE, 90 * MINUTE_IN_MS, 90 * MINUTE_IN_MS,
		90 * MINUTE_IN_MS);
		stats.noteScreenStateLocked(0, Display.STATE_OFF, 120 * MINUTE_IN_MS, 120 * MINUTE_IN_MS,
		120 * MINUTE_IN_MS);
		stats.noteScreenStateLocked(1, Display.STATE_OFF, 150 * MINUTE_IN_MS, 150 * MINUTE_IN_MS,
		150 * MINUTE_IN_MS);

		AmbientDisplayPowerCalculator calculator =
		new AmbientDisplayPowerCalculator(mStatsRule.getPowerProfile());

		mStatsRule.apply(BatteryUsageStatsRule.POWER_PROFILE_MODEL_ONLY, calculator);

		BatteryConsumer consumer = mStatsRule.getDeviceBatteryConsumer();
		// Duration should only be the union of
		assertThat(consumer.getUsageDurationMillis(BatteryConsumer.POWER_COMPONENT_AMBIENT_DISPLAY))
		.isEqualTo(120 * MINUTE_IN_MS);
		assertThat(consumer.getConsumedPower(BatteryConsumer.POWER_COMPONENT_AMBIENT_DISPLAY))
		.isWithin(PRECISION).of(35.0);
		assertThat(consumer.getPowerModel(BatteryConsumer.POWER_COMPONENT_AMBIENT_DISPLAY))
		.isEqualTo(BatteryConsumer.POWER_MODEL_POWER_PROFILE);
		}
		}