Merge "Convert WifiPowerCalculator to work with BatteryUsageStats" into sc-dev (2863f6a4) · Commits · e / os / android_frameworks_base

core/java/android/os/BatteryConsumer.java

+4 −0

Original line number	Diff line number	Diff line
		@@ -47,6 +47,7 @@ public abstract class BatteryConsumer {
		POWER_COMPONENT_SYSTEM_SERVICES,
		POWER_COMPONENT_SENSORS,
		POWER_COMPONENT_GNSS,
		POWER_COMPONENT_WIFI,
		POWER_COMPONENT_WAKELOCK,
		POWER_COMPONENT_SCREEN,
		POWER_COMPONENT_REATTRIBUTED_TO_OTHER_CONSUMERS,
		@@ -66,6 +67,7 @@ public abstract class BatteryConsumer {
		public static final int POWER_COMPONENT_MOBILE_RADIO = 8;
		public static final int POWER_COMPONENT_SENSORS = 9;
		public static final int POWER_COMPONENT_GNSS = 10;
		public static final int POWER_COMPONENT_WIFI = 11;
		public static final int POWER_COMPONENT_WAKELOCK = 12;
		public static final int POWER_COMPONENT_SCREEN = 13;
		// Power that is re-attributed to other battery consumers. For example, for System Server
		@@ -94,6 +96,7 @@ public abstract class BatteryConsumer {
		TIME_COMPONENT_MOBILE_RADIO,
		TIME_COMPONENT_SENSORS,
		TIME_COMPONENT_GNSS,
		TIME_COMPONENT_WIFI,
		TIME_COMPONENT_WAKELOCK,
		TIME_COMPONENT_SCREEN,
		})
		@@ -112,6 +115,7 @@ public abstract class BatteryConsumer {
		public static final int TIME_COMPONENT_MOBILE_RADIO = 8;
		public static final int TIME_COMPONENT_SENSORS = 9;
		public static final int TIME_COMPONENT_GNSS = 10;
		public static final int TIME_COMPONENT_WIFI = 11;
		public static final int TIME_COMPONENT_WAKELOCK = 12;
		public static final int TIME_COMPONENT_SCREEN = 13;

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

+4 −0

Original line number	Diff line number	Diff line
		@@ -32,6 +32,10 @@ public class UsageBasedPowerEstimator {
		mAveragePowerMahPerMs = averagePowerMilliAmp / MILLIS_IN_HOUR;
		}

		public boolean isSupported() {
		return mAveragePowerMahPerMs != 0;
		}

		/**
		* Given a {@link BatteryStats.Timer}, returns the accumulated duration.
		*/

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

+206 −82

Original line number	Diff line number	Diff line
		@@ -15,8 +15,13 @@
		*/
		package com.android.internal.os;

		import android.os.BatteryConsumer;
		import android.os.BatteryStats;
		import android.os.BatteryUsageStats;
		import android.os.BatteryUsageStatsQuery;
		import android.os.Process;
		import android.os.SystemBatteryConsumer;
		import android.os.UidBatteryConsumer;
		import android.os.UserHandle;
		import android.util.Log;
		import android.util.SparseArray;
		@@ -30,25 +35,93 @@ import java.util.List;
		public class WifiPowerCalculator extends PowerCalculator {
		private static final boolean DEBUG = BatteryStatsHelper.DEBUG;
		private static final String TAG = "WifiPowerCalculator";
		private final double mIdleCurrentMa;
		private final double mTxCurrentMa;
		private final double mRxCurrentMa;
		private final PowerProfile mPowerProfile;
		private final UsageBasedPowerEstimator mIdlePowerEstimator;
		private final UsageBasedPowerEstimator mTxPowerEstimator;
		private final UsageBasedPowerEstimator mRxPowerEstimator;
		private final UsageBasedPowerEstimator mPowerOnPowerEstimator;
		private final UsageBasedPowerEstimator mScanPowerEstimator;
		private final UsageBasedPowerEstimator mBatchScanPowerEstimator;
		private final boolean mHasWifiPowerController;
		private double mTotalAppPowerDrain = 0;
		private long mTotalAppRunningTime = 0;
		private WifiPowerEstimator mWifiPowerEstimator;
		private boolean mHasWifiPowerReporting;
		private final double mWifiPowerPerPacket;

		private static class PowerDurationAndTraffic {
		public double powerMah;
		public long durationMs;

		public long wifiRxPackets;
		public long wifiTxPackets;
		public long wifiRxBytes;
		public long wifiTxBytes;
		}

		public WifiPowerCalculator(PowerProfile profile) {
		mPowerProfile = profile;
		mPowerOnPowerEstimator = new UsageBasedPowerEstimator(
		profile.getAveragePower(PowerProfile.POWER_WIFI_ON));
		mScanPowerEstimator = new UsageBasedPowerEstimator(
		profile.getAveragePower(PowerProfile.POWER_WIFI_SCAN));
		mBatchScanPowerEstimator = new UsageBasedPowerEstimator(
		profile.getAveragePower(PowerProfile.POWER_WIFI_BATCHED_SCAN));
		mIdlePowerEstimator = new UsageBasedPowerEstimator(
		profile.getAveragePower(PowerProfile.POWER_WIFI_CONTROLLER_IDLE));
		mTxPowerEstimator = new UsageBasedPowerEstimator(
		profile.getAveragePower(PowerProfile.POWER_WIFI_CONTROLLER_TX));
		mRxPowerEstimator = new UsageBasedPowerEstimator(
		profile.getAveragePower(PowerProfile.POWER_WIFI_CONTROLLER_RX));

		mIdleCurrentMa = profile.getAveragePower(PowerProfile.POWER_WIFI_CONTROLLER_IDLE);
		mTxCurrentMa = profile.getAveragePower(PowerProfile.POWER_WIFI_CONTROLLER_TX);
		mRxCurrentMa = profile.getAveragePower(PowerProfile.POWER_WIFI_CONTROLLER_RX);
		mWifiPowerPerPacket = getWifiPowerPerPacket(profile);

		mHasWifiPowerController = mIdleCurrentMa != 0 && mTxCurrentMa != 0 && mRxCurrentMa != 0;
		mWifiPowerEstimator = new WifiPowerEstimator(mPowerProfile);
		mHasWifiPowerController =
		mIdlePowerEstimator.isSupported() && mTxPowerEstimator.isSupported()
		&& mRxPowerEstimator.isSupported();
		}

		@Override
		public void calculate(BatteryUsageStats.Builder builder, BatteryStats batteryStats,
		long rawRealtimeUs, long rawUptimeUs, BatteryUsageStatsQuery query) {

		// batteryStats.hasWifiActivityReporting can change if we get energy data at a later point,
		// so always check this field.
		final boolean hasWifiPowerReporting =
		mHasWifiPowerController && batteryStats.hasWifiActivityReporting();

		final SystemBatteryConsumer.Builder systemBatteryConsumerBuilder =
		builder.getOrCreateSystemBatteryConsumerBuilder(
		SystemBatteryConsumer.DRAIN_TYPE_WIFI);

		long totalAppDurationMs = 0;
		double totalAppPowerMah = 0;
		final PowerDurationAndTraffic powerDurationAndTraffic = new PowerDurationAndTraffic();
		final SparseArray<UidBatteryConsumer.Builder> uidBatteryConsumerBuilders =
		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,
		hasWifiPowerReporting);

		totalAppDurationMs += powerDurationAndTraffic.durationMs;
		totalAppPowerMah += powerDurationAndTraffic.powerMah;

		app.setUsageDurationMillis(BatteryConsumer.TIME_COMPONENT_WIFI,
		powerDurationAndTraffic.durationMs);
		app.setConsumedPower(BatteryConsumer.POWER_COMPONENT_WIFI,
		powerDurationAndTraffic.powerMah);

		if (app.getUid() == Process.WIFI_UID) {
		systemBatteryConsumerBuilder.addUidBatteryConsumer(app);
		app.excludeFromBatteryUsageStats();
		}
		}

		calculateRemaining(powerDurationAndTraffic, batteryStats, rawRealtimeUs,
		BatteryStats.STATS_SINCE_CHARGED,
		hasWifiPowerReporting, totalAppDurationMs, totalAppPowerMah);

		systemBatteryConsumerBuilder
		.setUsageDurationMillis(BatteryConsumer.TIME_COMPONENT_WIFI,
		powerDurationAndTraffic.durationMs)
		.setConsumedPower(BatteryConsumer.POWER_COMPONENT_WIFI,
		powerDurationAndTraffic.powerMah);
		}

		/**
		@@ -64,100 +137,151 @@ public class WifiPowerCalculator extends PowerCalculator {

		// batteryStats.hasWifiActivityReporting can change if we get energy data at a later point,
		// so always check this field.
		mHasWifiPowerReporting = mHasWifiPowerController && batteryStats.hasWifiActivityReporting();
		final boolean hasWifiPowerReporting =
		mHasWifiPowerController && batteryStats.hasWifiActivityReporting();

		super.calculate(sippers, batteryStats, rawRealtimeUs, rawUptimeUs, statsType, asUsers);

		BatterySipper bs = new BatterySipper(BatterySipper.DrainType.WIFI, null, 0);
		calculateRemaining(bs, batteryStats, rawRealtimeUs, rawUptimeUs, statsType);
		final BatterySipper bs = new BatterySipper(BatterySipper.DrainType.WIFI, null, 0);

		long totalAppDurationMs = 0;
		double totalAppPowerMah = 0;
		final PowerDurationAndTraffic powerDurationAndTraffic = new PowerDurationAndTraffic();
		for (int i = sippers.size() - 1; i >= 0; i--) {
		BatterySipper app = sippers.get(i);
		final BatterySipper app = sippers.get(i);
		if (app.drainType == BatterySipper.DrainType.APP) {
		calculateApp(powerDurationAndTraffic, app.uidObj, rawRealtimeUs, statsType,
		hasWifiPowerReporting);

		totalAppDurationMs += powerDurationAndTraffic.durationMs;
		totalAppPowerMah += powerDurationAndTraffic.powerMah;

		app.wifiPowerMah = powerDurationAndTraffic.powerMah;
		app.wifiRunningTimeMs = powerDurationAndTraffic.durationMs;
		app.wifiRxBytes = powerDurationAndTraffic.wifiRxBytes;
		app.wifiRxPackets = powerDurationAndTraffic.wifiRxPackets;
		app.wifiTxBytes = powerDurationAndTraffic.wifiTxBytes;
		app.wifiTxPackets = powerDurationAndTraffic.wifiTxPackets;
		if (app.getUid() == Process.WIFI_UID) {
		if (DEBUG) Log.d(TAG, "WiFi adding sipper " + app + ": cpu=" + app.cpuTimeMs);
		app.isAggregated = true;
		bs.add(app);
		}
		}
		}

		calculateRemaining(powerDurationAndTraffic, batteryStats, rawRealtimeUs, statsType,
		hasWifiPowerReporting, totalAppDurationMs, totalAppPowerMah);

		bs.wifiRunningTimeMs += powerDurationAndTraffic.durationMs;
		bs.wifiPowerMah += powerDurationAndTraffic.powerMah;

		if (bs.sumPower() > 0) {
		sippers.add(bs);
		}
		}

		@Override
		protected void calculateApp(BatterySipper app, BatteryStats.Uid u, long rawRealtimeUs,
		long rawUptimeUs, int statsType) {
		if (!mHasWifiPowerReporting) {
		mWifiPowerEstimator.calculateApp(app, u, rawRealtimeUs, rawUptimeUs, statsType);
		return;
		}
		private void calculateApp(PowerDurationAndTraffic powerDurationAndTraffic, BatteryStats.Uid u,
		long rawRealtimeUs,
		int statsType, boolean hasWifiPowerReporting) {
		powerDurationAndTraffic.wifiRxPackets = u.getNetworkActivityPackets(
		BatteryStats.NETWORK_WIFI_RX_DATA,
		statsType);
		powerDurationAndTraffic.wifiTxPackets = u.getNetworkActivityPackets(
		BatteryStats.NETWORK_WIFI_TX_DATA,
		statsType);
		powerDurationAndTraffic.wifiRxBytes = u.getNetworkActivityBytes(
		BatteryStats.NETWORK_WIFI_RX_DATA,
		statsType);
		powerDurationAndTraffic.wifiTxBytes = u.getNetworkActivityBytes(
		BatteryStats.NETWORK_WIFI_TX_DATA,
		statsType);

		if (hasWifiPowerReporting) {
		final BatteryStats.ControllerActivityCounter counter = u.getWifiControllerActivity();
		if (counter == null) {
		return;
		}

		if (counter != null) {
		final long idleTime = counter.getIdleTimeCounter().getCountLocked(statsType);
		final long txTime = counter.getTxTimeCounters()[0].getCountLocked(statsType);
		final long rxTime = counter.getRxTimeCounter().getCountLocked(statsType);
		app.wifiRunningTimeMs = idleTime + rxTime + txTime;
		mTotalAppRunningTime += app.wifiRunningTimeMs;

		app.wifiPowerMah =
		((idleTime * mIdleCurrentMa) + (txTime * mTxCurrentMa) + (rxTime * mRxCurrentMa))
		/ (1000 * 60 * 60);
		mTotalAppPowerDrain += app.wifiPowerMah;

		app.wifiRxPackets = u.getNetworkActivityPackets(BatteryStats.NETWORK_WIFI_RX_DATA,
		statsType);
		app.wifiTxPackets = u.getNetworkActivityPackets(BatteryStats.NETWORK_WIFI_TX_DATA,
		statsType);
		app.wifiRxBytes = u.getNetworkActivityBytes(BatteryStats.NETWORK_WIFI_RX_DATA,
		statsType);
		app.wifiTxBytes = u.getNetworkActivityBytes(BatteryStats.NETWORK_WIFI_TX_DATA,
		statsType);
		powerDurationAndTraffic.durationMs = idleTime + rxTime + txTime;
		powerDurationAndTraffic.powerMah = mIdlePowerEstimator.calculatePower(idleTime)
		+ mTxPowerEstimator.calculatePower(txTime)
		+ mRxPowerEstimator.calculatePower(rxTime);

		if (DEBUG && app.wifiPowerMah != 0) {
		Log.d(TAG, "UID " + u.getUid() + ": idle=" + idleTime + "ms rx=" + rxTime + "ms tx=" +
		txTime + "ms power=" + formatCharge(app.wifiPowerMah));
		if (DEBUG && powerDurationAndTraffic.powerMah != 0) {
		Log.d(TAG, "UID " + u.getUid() + ": idle=" + idleTime + "ms rx=" + rxTime
		+ "ms tx=" + txTime + "ms power=" + formatCharge(
		powerDurationAndTraffic.powerMah));
		}
		}
		} else {
		final double wifiPacketPower = (
		powerDurationAndTraffic.wifiRxPackets + powerDurationAndTraffic.wifiTxPackets)
		* mWifiPowerPerPacket;
		final long wifiRunningTime = u.getWifiRunningTime(rawRealtimeUs, statsType) / 1000;
		final long wifiScanTimeMs = u.getWifiScanTime(rawRealtimeUs, statsType) / 1000;
		long batchScanTimeMs = 0;
		for (int bin = 0; bin < BatteryStats.Uid.NUM_WIFI_BATCHED_SCAN_BINS; bin++) {
		batchScanTimeMs += u.getWifiBatchedScanTime(bin, rawRealtimeUs, statsType) / 1000;
		}

		private void calculateRemaining(BatterySipper app, BatteryStats stats, long rawRealtimeUs,
		long rawUptimeUs, int statsType) {
		if (!mHasWifiPowerReporting) {
		mWifiPowerEstimator.calculateRemaining(app, stats, rawRealtimeUs, rawUptimeUs,
		statsType);
		return;
		powerDurationAndTraffic.durationMs = wifiRunningTime;
		powerDurationAndTraffic.powerMah = wifiPacketPower
		+ mPowerOnPowerEstimator.calculatePower(wifiRunningTime)
		+ mScanPowerEstimator.calculatePower(wifiScanTimeMs)
		+ mBatchScanPowerEstimator.calculatePower(batchScanTimeMs);

		if (DEBUG && powerDurationAndTraffic.powerMah != 0) {
		Log.d(TAG, "UID " + u.getUid() + ": power=" + formatCharge(
		powerDurationAndTraffic.powerMah));
		}
		}
		}

		final BatteryStats.ControllerActivityCounter counter = stats.getWifiControllerActivity();
		private void calculateRemaining(PowerDurationAndTraffic powerDurationAndTraffic,
		BatteryStats stats, long rawRealtimeUs,
		int statsType, boolean hasWifiPowerReporting, long totalAppDurationMs,
		double totalAppPowerMah) {
		long totalDurationMs;
		double totalPowerMah;
		if (hasWifiPowerReporting) {
		final BatteryStats.ControllerActivityCounter counter =
		stats.getWifiControllerActivity();

		final long idleTimeMs = counter.getIdleTimeCounter().getCountLocked(statsType);
		final long txTimeMs = counter.getTxTimeCounters()[0].getCountLocked(statsType);
		final long rxTimeMs = counter.getRxTimeCounter().getCountLocked(statsType);

		app.wifiRunningTimeMs = Math.max(0,
		(idleTimeMs + rxTimeMs + txTimeMs) - mTotalAppRunningTime);
		totalDurationMs = idleTimeMs + rxTimeMs + txTimeMs;

		double powerDrainMah = counter.getPowerCounter().getCountLocked(statsType)
		/ (double) (1000 * 60 * 60);
		if (powerDrainMah == 0) {
		totalPowerMah =
		counter.getPowerCounter().getCountLocked(statsType) / (double) (1000 * 60 * 60);
		if (totalPowerMah == 0) {
		// Some controllers do not report power drain, so we can calculate it here.
		powerDrainMah = ((idleTimeMs * mIdleCurrentMa) + (txTimeMs * mTxCurrentMa)
		+ (rxTimeMs * mRxCurrentMa)) / (1000 * 60 * 60);
		totalPowerMah = mIdlePowerEstimator.calculatePower(idleTimeMs)
		+ mTxPowerEstimator.calculatePower(txTimeMs)
		+ mRxPowerEstimator.calculatePower(rxTimeMs);
		}
		} else {
		totalDurationMs = stats.getGlobalWifiRunningTime(rawRealtimeUs, statsType) / 1000;
		totalPowerMah = mPowerOnPowerEstimator.calculatePower(totalDurationMs);
		}
		app.wifiPowerMah = Math.max(0, powerDrainMah - mTotalAppPowerDrain);

		powerDurationAndTraffic.durationMs = Math.max(0, totalDurationMs - totalAppDurationMs);
		powerDurationAndTraffic.powerMah = Math.max(0, totalPowerMah - totalAppPowerMah);

		if (DEBUG) {
		Log.d(TAG, "left over WiFi power: " + formatCharge(app.wifiPowerMah));
		Log.d(TAG, "left over WiFi power: " + formatCharge(powerDurationAndTraffic.powerMah));
		}
		}

		@Override
		public void reset() {
		mTotalAppPowerDrain = 0;
		mTotalAppRunningTime = 0;
		mWifiPowerEstimator.reset();
		/**
		* Return estimated power per Wi-Fi packet in mAh/packet where 1 packet = 2 KB.
		*/
		private static double getWifiPowerPerPacket(PowerProfile profile) {
		// TODO(b/179392913): Extract average bit rates from system
		final long wifiBps = 1000000;
		final double averageWifiActivePower =
		profile.getAveragePower(PowerProfile.POWER_WIFI_ACTIVE) / 3600;
		return averageWifiActivePower / (((double) wifiBps) / 8 / 2048);
		}
		}

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

deleted100644 → 0

+0 −126

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2015 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/
		package com.android.internal.os;

		import android.os.BatteryStats;
		import android.os.Process;
		import android.os.UserHandle;
		import android.util.Log;
		import android.util.SparseArray;

		import java.util.List;

		/**
		* Estimates WiFi power usage based on timers in BatteryStats.
		*/
		public class WifiPowerEstimator extends PowerCalculator {
		private static final boolean DEBUG = BatteryStatsHelper.DEBUG;
		private static final String TAG = "WifiPowerEstimator";
		private final double mWifiPowerPerPacket;
		private final double mWifiPowerOn;
		private final double mWifiPowerScan;
		private final double mWifiPowerBatchScan;
		private long mTotalAppWifiRunningTimeMs = 0;

		public WifiPowerEstimator(PowerProfile profile) {
		mWifiPowerPerPacket = getWifiPowerPerPacket(profile);
		mWifiPowerOn = profile.getAveragePower(PowerProfile.POWER_WIFI_ON);
		mWifiPowerScan = profile.getAveragePower(PowerProfile.POWER_WIFI_SCAN);
		mWifiPowerBatchScan = profile.getAveragePower(PowerProfile.POWER_WIFI_BATCHED_SCAN);
		}

		@Override
		public void calculate(List<BatterySipper> sippers, BatteryStats batteryStats,
		long rawRealtimeUs, long rawUptimeUs, int statsType, SparseArray<UserHandle> asUsers) {
		super.calculate(sippers, batteryStats, rawRealtimeUs, rawUptimeUs, statsType, asUsers);

		BatterySipper bs = new BatterySipper(BatterySipper.DrainType.WIFI, null, 0);
		calculateRemaining(bs, batteryStats, rawRealtimeUs, rawUptimeUs, statsType);

		for (int i = sippers.size() - 1; i >= 0; i--) {
		BatterySipper app = sippers.get(i);
		if (app.getUid() == Process.WIFI_UID) {
		if (DEBUG) Log.d(TAG, "WiFi adding sipper " + app + ": cpu=" + app.cpuTimeMs);
		app.isAggregated = true;
		bs.add(app);
		}
		}
		if (bs.sumPower() > 0) {
		sippers.add(bs);
		}
		}

		/**
		* Return estimated power per Wi-Fi packet in mAh/packet where 1 packet = 2 KB.
		*/
		private static double getWifiPowerPerPacket(PowerProfile profile) {
		final long WIFI_BPS = 1000000; // TODO: Extract average bit rates from system
		final double WIFI_POWER = profile.getAveragePower(PowerProfile.POWER_WIFI_ACTIVE)
		/ 3600;
		return WIFI_POWER / (((double)WIFI_BPS) / 8 / 2048);
		}

		@Override
		protected void calculateApp(BatterySipper app, BatteryStats.Uid u, long rawRealtimeUs,
		long rawUptimeUs, int statsType) {
		app.wifiRxPackets = u.getNetworkActivityPackets(BatteryStats.NETWORK_WIFI_RX_DATA,
		statsType);
		app.wifiTxPackets = u.getNetworkActivityPackets(BatteryStats.NETWORK_WIFI_TX_DATA,
		statsType);
		app.wifiRxBytes = u.getNetworkActivityBytes(BatteryStats.NETWORK_WIFI_RX_DATA,
		statsType);
		app.wifiTxBytes = u.getNetworkActivityBytes(BatteryStats.NETWORK_WIFI_TX_DATA,
		statsType);

		final double wifiPacketPower = (app.wifiRxPackets + app.wifiTxPackets)
		* mWifiPowerPerPacket;

		app.wifiRunningTimeMs = u.getWifiRunningTime(rawRealtimeUs, statsType) / 1000;
		mTotalAppWifiRunningTimeMs += app.wifiRunningTimeMs;
		final double wifiLockPower = (app.wifiRunningTimeMs * mWifiPowerOn) / (10006060);

		final long wifiScanTimeMs = u.getWifiScanTime(rawRealtimeUs, statsType) / 1000;
		final double wifiScanPower = (wifiScanTimeMs * mWifiPowerScan) / (10006060);

		double wifiBatchScanPower = 0;
		for (int bin = 0; bin < BatteryStats.Uid.NUM_WIFI_BATCHED_SCAN_BINS; bin++) {
		final long batchScanTimeMs =
		u.getWifiBatchedScanTime(bin, rawRealtimeUs, statsType) / 1000;
		final double batchScanPower = (batchScanTimeMs * mWifiPowerBatchScan) / (10006060);
		wifiBatchScanPower += batchScanPower;
		}

		app.wifiPowerMah = wifiPacketPower + wifiLockPower + wifiScanPower + wifiBatchScanPower;
		if (DEBUG && app.wifiPowerMah != 0) {
		Log.d(TAG, "UID " + u.getUid() + ": power=" + formatCharge(app.wifiPowerMah));
		}
		}

		void calculateRemaining(BatterySipper app, BatteryStats stats, long rawRealtimeUs,
		long rawUptimeUs, int statsType) {
		final long totalRunningTimeMs = stats.getGlobalWifiRunningTime(rawRealtimeUs, statsType)
		/ 1000;
		final double powerDrain = ((totalRunningTimeMs - mTotalAppWifiRunningTimeMs) * mWifiPowerOn)
		/ (10006060);
		app.wifiRunningTimeMs = totalRunningTimeMs;
		app.wifiPowerMah = Math.max(0, powerDrain);
		}

		@Override
		public void reset() {
		mTotalAppWifiRunningTimeMs = 0;
		}
		}

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

+1 −0

Original line number	Diff line number	Diff line
		@@ -71,6 +71,7 @@ import org.junit.runners.Suite;
		UserPowerCalculatorTest.class,
		VideoPowerCalculatorTest.class,
		WakelockPowerCalculatorTest.class,
		WifiPowerCalculatorTest.class,

		com.android.internal.power.MeasuredEnergyStatsTest.class
		})