From b50a684ba8310a7d9b9738f9304b029268dedd64 Mon Sep 17 00:00:00 2001 From: Siddharth Ray Date: Thu, 14 Dec 2017 15:15:28 -0800 Subject: [PATCH] Wifi: Add scanning, activity time and API Addition of Wifi Scanning time to Aggregate BatteryStats Addition of Wifi Active time to BatteryStats (aggregate) Addition of API to obtain Wifi battery stats for power drain diagnostics. BUG:67213886 Test: Manual Change-Id: I4f4c27ba839017d44feca685a4fae2f130d31765 --- core/java/android/os/BatteryStats.java | 55 +++- .../android/os/connectivity/WifiBatteryStats.aidl | 20 ++ .../android/os/connectivity/WifiBatteryStats.java | 279 +++++++++++++++++++++ .../com/android/internal/app/IBatteryStats.aidl | 4 + .../com/android/internal/os/BatteryStatsImpl.java | 102 +++++++- .../server/am/BatteryExternalStatsWorker.java | 8 +- .../com/android/server/am/BatteryStatsService.java | 11 + .../android/net/wifi/WifiActivityEnergyInfo.java | 25 +- 8 files changed, 485 insertions(+), 19 deletions(-) create mode 100644 core/java/android/os/connectivity/WifiBatteryStats.aidl create mode 100644 core/java/android/os/connectivity/WifiBatteryStats.java diff --git a/core/java/android/os/BatteryStats.java b/core/java/android/os/BatteryStats.java index 49879a8a84a7..03a8dba5a82c 100644 --- a/core/java/android/os/BatteryStats.java +++ b/core/java/android/os/BatteryStats.java @@ -336,6 +336,9 @@ public abstract class BatteryStats implements Parcelable { private final StringBuilder mFormatBuilder = new StringBuilder(32); private final Formatter mFormatter = new Formatter(mFormatBuilder); + private static final String CELLULAR_CONTROLLER_NAME = "Cellular"; + private static final String WIFI_CONTROLLER_NAME = "WiFi"; + /** * Indicates times spent by the uid at each cpu frequency in all process states. * @@ -413,6 +416,13 @@ public abstract class BatteryStats implements Parcelable { /** * @return a non-null {@link LongCounter} representing time spent (milliseconds) in the + * scan state. + */ + public abstract LongCounter getScanTimeCounter(); + + + /** + * @return a non-null {@link LongCounter} representing time spent (milliseconds) in the * receive state. */ public abstract LongCounter getRxTimeCounter(); @@ -2399,6 +2409,14 @@ public abstract class BatteryStats implements Parcelable { public abstract long getWifiOnTime(long elapsedRealtimeUs, int which); /** + * Returns the time in microseconds that wifi has been active while the device was + * running on battery. + * + * {@hide} + */ + public abstract long getWifiActiveTime(long elapsedRealtimeUs, int which); + + /** * Returns the time in microseconds that wifi has been on and the driver has * been in the running state while the device was running on battery. * @@ -3345,6 +3363,20 @@ public abstract class BatteryStats implements Parcelable { final long sleepTimeMs = totalControllerActivityTimeMs - (idleTimeMs + rxTimeMs + totalTxTimeMs); + if (controllerName.equals(WIFI_CONTROLLER_NAME)) { + final long scanTimeMs = counter.getScanTimeCounter().getCountLocked(which); + sb.setLength(0); + sb.append(prefix); + sb.append(" "); + sb.append(controllerName); + sb.append(" Scan time: "); + formatTimeMs(sb, scanTimeMs); + sb.append("("); + sb.append(formatRatioLocked(scanTimeMs, totalControllerActivityTimeMs)); + sb.append(")"); + pw.println(sb.toString()); + } + sb.setLength(0); sb.append(prefix); sb.append(" "); @@ -3386,7 +3418,7 @@ public abstract class BatteryStats implements Parcelable { String [] powerLevel; switch(controllerName) { - case "Cellular": + case CELLULAR_CONTROLLER_NAME: powerLevel = new String[] { " less than 0dBm: ", " 0dBm to 8dBm: ", @@ -4674,7 +4706,7 @@ public abstract class BatteryStats implements Parcelable { if (!didOne) sb.append(" (no activity)"); pw.println(sb.toString()); - printControllerActivity(pw, sb, prefix, "Cellular", + printControllerActivity(pw, sb, prefix, CELLULAR_CONTROLLER_NAME, getModemControllerActivity(), which); pw.print(prefix); @@ -4683,6 +4715,16 @@ public abstract class BatteryStats implements Parcelable { sb.append(" Wifi Statistics:"); pw.println(sb.toString()); + pw.print(prefix); + sb.setLength(0); + sb.append(prefix); + sb.append(" Wifi kernel active time: "); + final long wifiActiveTime = getWifiActiveTime(rawRealtime, which); + formatTimeMs(sb, wifiActiveTime / 1000); + sb.append("("); sb.append(formatRatioLocked(wifiActiveTime, whichBatteryRealtime)); + sb.append(")"); + pw.println(sb.toString()); + pw.print(" Wifi data received: "); pw.println(formatBytesLocked(wifiRxTotalBytes)); pw.print(" Wifi data sent: "); pw.println(formatBytesLocked(wifiTxTotalBytes)); pw.print(" Wifi packets received: "); pw.println(wifiRxTotalPackets); @@ -4760,7 +4802,8 @@ public abstract class BatteryStats implements Parcelable { if (!didOne) sb.append(" (no activity)"); pw.println(sb.toString()); - printControllerActivity(pw, sb, prefix, "WiFi", getWifiControllerActivity(), which); + printControllerActivity(pw, sb, prefix, WIFI_CONTROLLER_NAME, + getWifiControllerActivity(), which); pw.print(prefix); sb.setLength(0); @@ -5238,8 +5281,8 @@ public abstract class BatteryStats implements Parcelable { pw.println(sb.toString()); } - printControllerActivityIfInteresting(pw, sb, prefix + " ", "Modem", - u.getModemControllerActivity(), which); + printControllerActivityIfInteresting(pw, sb, prefix + " ", + CELLULAR_CONTROLLER_NAME, u.getModemControllerActivity(), which); if (wifiRxBytes > 0 || wifiTxBytes > 0 || wifiRxPackets > 0 || wifiTxPackets > 0) { pw.print(prefix); pw.print(" Wi-Fi network: "); @@ -5293,7 +5336,7 @@ public abstract class BatteryStats implements Parcelable { pw.println(sb.toString()); } - printControllerActivityIfInteresting(pw, sb, prefix + " ", "WiFi", + printControllerActivityIfInteresting(pw, sb, prefix + " ", WIFI_CONTROLLER_NAME, u.getWifiControllerActivity(), which); if (btRxBytes > 0 || btTxBytes > 0) { diff --git a/core/java/android/os/connectivity/WifiBatteryStats.aidl b/core/java/android/os/connectivity/WifiBatteryStats.aidl new file mode 100644 index 000000000000..12ac73828eed --- /dev/null +++ b/core/java/android/os/connectivity/WifiBatteryStats.aidl @@ -0,0 +1,20 @@ +/* + * Copyright (C) 2016 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 android.os.connectivity; + +/** {@hide} */ +parcelable WifiBatteryStats; \ No newline at end of file diff --git a/core/java/android/os/connectivity/WifiBatteryStats.java b/core/java/android/os/connectivity/WifiBatteryStats.java new file mode 100644 index 000000000000..e5341eeeb17b --- /dev/null +++ b/core/java/android/os/connectivity/WifiBatteryStats.java @@ -0,0 +1,279 @@ +/* + * Copyright (C) 2016 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 android.os.connectivity; + +import android.os.BatteryStats; +import android.os.Parcel; +import android.os.Parcelable; + +import java.util.Arrays; + +/** + * API for Wifi power stats + * + * @hide + */ +public final class WifiBatteryStats implements Parcelable { + + private long mLoggingDurationMs; + private long mKernelActiveTimeMs; + private long mNumPacketsTx; + private long mNumBytesTx; + private long mNumPacketsRx; + private long mNumBytesRx; + private long mSleepTimeMs; + private long mScanTimeMs; + private long mIdleTimeMs; + private long mRxTimeMs; + private long mTxTimeMs; + private long mEnergyConsumedMaMs; + private long mNumAppScanRequest; + private long[] mTimeInStateMs; + private long[] mTimeInSupplicantStateMs; + private long[] mTimeInRxSignalStrengthLevelMs; + + public static final Parcelable.Creator CREATOR = new + Parcelable.Creator() { + public WifiBatteryStats createFromParcel(Parcel in) { + return new WifiBatteryStats(in); + } + + public WifiBatteryStats[] newArray(int size) { + return new WifiBatteryStats[size]; + } + }; + + public WifiBatteryStats() { + initialize(); + } + + public void writeToParcel(Parcel out, int flags) { + out.writeLong(mLoggingDurationMs); + out.writeLong(mKernelActiveTimeMs); + out.writeLong(mNumPacketsTx); + out.writeLong(mNumBytesTx); + out.writeLong(mNumPacketsRx); + out.writeLong(mNumBytesRx); + out.writeLong(mSleepTimeMs); + out.writeLong(mScanTimeMs); + out.writeLong(mIdleTimeMs); + out.writeLong(mRxTimeMs); + out.writeLong(mTxTimeMs); + out.writeLong(mEnergyConsumedMaMs); + out.writeLong(mNumAppScanRequest); + out.writeLongArray(mTimeInStateMs); + out.writeLongArray(mTimeInRxSignalStrengthLevelMs); + out.writeLongArray(mTimeInSupplicantStateMs); + } + + public void readFromParcel(Parcel in) { + mLoggingDurationMs = in.readLong(); + mKernelActiveTimeMs = in.readLong(); + mNumPacketsTx = in.readLong(); + mNumBytesTx = in.readLong(); + mNumPacketsRx = in.readLong(); + mNumBytesRx = in.readLong(); + mSleepTimeMs = in.readLong(); + mScanTimeMs = in.readLong(); + mIdleTimeMs = in.readLong(); + mRxTimeMs = in.readLong(); + mTxTimeMs = in.readLong(); + mEnergyConsumedMaMs = in.readLong(); + mNumAppScanRequest = in.readLong(); + in.readLongArray(mTimeInStateMs); + in.readLongArray(mTimeInRxSignalStrengthLevelMs); + in.readLongArray(mTimeInSupplicantStateMs); + } + + public long getLoggingDurationMs() { + return mLoggingDurationMs; + } + + public long getKernelActiveTimeMs() { + return mKernelActiveTimeMs; + } + + public long getNumPacketsTx() { + return mNumPacketsTx; + } + + public long getNumBytesTx() { + return mNumBytesTx; + } + + public long getNumPacketsRx() { + return mNumPacketsRx; + } + + public long getNumBytesRx() { + return mNumBytesRx; + } + + public long getSleepTimeMs() { + return mSleepTimeMs; + } + + public long getScanTimeMs() { + return mScanTimeMs; + } + + public long getIdleTimeMs() { + return mIdleTimeMs; + } + + public long getRxTimeMs() { + return mRxTimeMs; + } + + public long getTxTimeMs() { + return mTxTimeMs; + } + + public long getEnergyConsumedMaMs() { + return mEnergyConsumedMaMs; + } + + public long getNumAppScanRequest() { + return mNumAppScanRequest; + } + + public long[] getTimeInStateMs() { + return mTimeInStateMs; + } + + public long[] getTimeInRxSignalStrengthLevelMs() { + return mTimeInRxSignalStrengthLevelMs; + } + + public long[] getTimeInSupplicantStateMs() { + return mTimeInSupplicantStateMs; + } + + public void setLoggingDurationMs(long t) { + mLoggingDurationMs = t; + return; + } + + public void setKernelActiveTimeMs(long t) { + mKernelActiveTimeMs = t; + return; + } + + public void setNumPacketsTx(long n) { + mNumPacketsTx = n; + return; + } + + public void setNumBytesTx(long b) { + mNumBytesTx = b; + return; + } + + public void setNumPacketsRx(long n) { + mNumPacketsRx = n; + return; + } + + public void setNumBytesRx(long b) { + mNumBytesRx = b; + return; + } + + public void setSleepTimeMs(long t) { + mSleepTimeMs = t; + return; + } + + public void setScanTimeMs(long t) { + mScanTimeMs = t; + return; + } + + public void setIdleTimeMs(long t) { + mIdleTimeMs = t; + return; + } + + public void setRxTimeMs(long t) { + mRxTimeMs = t; + return; + } + + public void setTxTimeMs(long t) { + mTxTimeMs = t; + return; + } + + public void setEnergyConsumedMaMs(long e) { + mEnergyConsumedMaMs = e; + return; + } + + public void setNumAppScanRequest(long n) { + mNumAppScanRequest = n; + return; + } + + public void setTimeInStateMs(long[] t) { + mTimeInStateMs = Arrays.copyOfRange(t, 0, + Math.min(t.length, BatteryStats.NUM_WIFI_STATES)); + return; + } + + public void setTimeInRxSignalStrengthLevelMs(long[] t) { + mTimeInRxSignalStrengthLevelMs = Arrays.copyOfRange(t, 0, + Math.min(t.length, BatteryStats.NUM_WIFI_SIGNAL_STRENGTH_BINS)); + return; + } + + public void setTimeInSupplicantStateMs(long[] t) { + mTimeInSupplicantStateMs = Arrays.copyOfRange( + t, 0, Math.min(t.length, BatteryStats.NUM_WIFI_SUPPL_STATES)); + return; + } + + public int describeContents() { + return 0; + } + + private WifiBatteryStats(Parcel in) { + initialize(); + readFromParcel(in); + } + + private void initialize() { + mLoggingDurationMs = 0; + mKernelActiveTimeMs = 0; + mNumPacketsTx = 0; + mNumBytesTx = 0; + mNumPacketsRx = 0; + mNumBytesRx = 0; + mSleepTimeMs = 0; + mScanTimeMs = 0; + mIdleTimeMs = 0; + mRxTimeMs = 0; + mTxTimeMs = 0; + mEnergyConsumedMaMs = 0; + mNumAppScanRequest = 0; + mTimeInStateMs = new long[BatteryStats.NUM_WIFI_STATES]; + Arrays.fill(mTimeInStateMs, 0); + mTimeInRxSignalStrengthLevelMs = new long[BatteryStats.NUM_WIFI_SIGNAL_STRENGTH_BINS]; + Arrays.fill(mTimeInRxSignalStrengthLevelMs, 0); + mTimeInSupplicantStateMs = new long[BatteryStats.NUM_WIFI_SUPPL_STATES]; + Arrays.fill(mTimeInSupplicantStateMs, 0); + return; + } +} \ No newline at end of file diff --git a/core/java/com/android/internal/app/IBatteryStats.aidl b/core/java/com/android/internal/app/IBatteryStats.aidl index e2d1ad59043e..d3e807d99990 100644 --- a/core/java/com/android/internal/app/IBatteryStats.aidl +++ b/core/java/com/android/internal/app/IBatteryStats.aidl @@ -23,6 +23,7 @@ import android.net.wifi.WifiActivityEnergyInfo; import android.os.ParcelFileDescriptor; import android.os.WorkSource; import android.os.connectivity.CellularBatteryStats; +import android.os.connectivity.WifiBatteryStats; import android.os.connectivity.GpsBatteryStats; import android.os.health.HealthStatsParceler; import android.telephony.DataConnectionRealTimeInfo; @@ -143,6 +144,9 @@ interface IBatteryStats { CellularBatteryStats getCellularBatteryStats(); /** {@hide} */ + WifiBatteryStats getWifiBatteryStats(); + + /** {@hide} */ GpsBatteryStats getGpsBatteryStats(); HealthStatsParceler takeUidSnapshot(int uid); diff --git a/core/java/com/android/internal/os/BatteryStatsImpl.java b/core/java/com/android/internal/os/BatteryStatsImpl.java index 799e3e8d38d0..3c99467806a1 100644 --- a/core/java/com/android/internal/os/BatteryStatsImpl.java +++ b/core/java/com/android/internal/os/BatteryStatsImpl.java @@ -34,6 +34,7 @@ import android.os.BatteryManager; import android.os.BatteryStats; import android.os.Build; import android.os.connectivity.CellularBatteryStats; +import android.os.connectivity.WifiBatteryStats; import android.os.connectivity.GpsBatteryStats; import android.os.FileUtils; import android.os.Handler; @@ -131,7 +132,7 @@ public class BatteryStatsImpl extends BatteryStats { private static final int MAGIC = 0xBA757475; // 'BATSTATS' // Current on-disk Parcel version - private static final int VERSION = 173 + (USE_OLD_HISTORY ? 1000 : 0); + private static final int VERSION = 174 + (USE_OLD_HISTORY ? 1000 : 0); // Maximum number of items we will record in the history. private static final int MAX_HISTORY_ITEMS; @@ -751,6 +752,8 @@ public class BatteryStatsImpl extends BatteryStats { final StopwatchTimer[] mWifiSignalStrengthsTimer = new StopwatchTimer[NUM_WIFI_SIGNAL_STRENGTH_BINS]; + StopwatchTimer mWifiActiveTimer; + int mBluetoothScanNesting; @VisibleForTesting(visibility = VisibleForTesting.Visibility.PACKAGE) protected StopwatchTimer mBluetoothScanTimer; @@ -2785,12 +2788,14 @@ public class BatteryStatsImpl extends BatteryStats { public static class ControllerActivityCounterImpl extends ControllerActivityCounter implements Parcelable { private final LongSamplingCounter mIdleTimeMillis; + private final LongSamplingCounter mScanTimeMillis; private final LongSamplingCounter mRxTimeMillis; private final LongSamplingCounter[] mTxTimeMillis; private final LongSamplingCounter mPowerDrainMaMs; public ControllerActivityCounterImpl(TimeBase timeBase, int numTxStates) { mIdleTimeMillis = new LongSamplingCounter(timeBase); + mScanTimeMillis = new LongSamplingCounter(timeBase); mRxTimeMillis = new LongSamplingCounter(timeBase); mTxTimeMillis = new LongSamplingCounter[numTxStates]; for (int i = 0; i < numTxStates; i++) { @@ -2801,6 +2806,7 @@ public class BatteryStatsImpl extends BatteryStats { public ControllerActivityCounterImpl(TimeBase timeBase, int numTxStates, Parcel in) { mIdleTimeMillis = new LongSamplingCounter(timeBase, in); + mScanTimeMillis = new LongSamplingCounter(timeBase, in); mRxTimeMillis = new LongSamplingCounter(timeBase, in); final int recordedTxStates = in.readInt(); if (recordedTxStates != numTxStates) { @@ -2816,6 +2822,7 @@ public class BatteryStatsImpl extends BatteryStats { public void readSummaryFromParcel(Parcel in) { mIdleTimeMillis.readSummaryFromParcelLocked(in); + mScanTimeMillis.readSummaryFromParcelLocked(in); mRxTimeMillis.readSummaryFromParcelLocked(in); final int recordedTxStates = in.readInt(); if (recordedTxStates != mTxTimeMillis.length) { @@ -2834,6 +2841,7 @@ public class BatteryStatsImpl extends BatteryStats { public void writeSummaryToParcel(Parcel dest) { mIdleTimeMillis.writeSummaryFromParcelLocked(dest); + mScanTimeMillis.writeSummaryFromParcelLocked(dest); mRxTimeMillis.writeSummaryFromParcelLocked(dest); dest.writeInt(mTxTimeMillis.length); for (LongSamplingCounter counter : mTxTimeMillis) { @@ -2845,6 +2853,7 @@ public class BatteryStatsImpl extends BatteryStats { @Override public void writeToParcel(Parcel dest, int flags) { mIdleTimeMillis.writeToParcel(dest); + mScanTimeMillis.writeToParcel(dest); mRxTimeMillis.writeToParcel(dest); dest.writeInt(mTxTimeMillis.length); for (LongSamplingCounter counter : mTxTimeMillis) { @@ -2855,6 +2864,7 @@ public class BatteryStatsImpl extends BatteryStats { public void reset(boolean detachIfReset) { mIdleTimeMillis.reset(detachIfReset); + mScanTimeMillis.reset(detachIfReset); mRxTimeMillis.reset(detachIfReset); for (LongSamplingCounter counter : mTxTimeMillis) { counter.reset(detachIfReset); @@ -2864,6 +2874,7 @@ public class BatteryStatsImpl extends BatteryStats { public void detach() { mIdleTimeMillis.detach(); + mScanTimeMillis.detach(); mRxTimeMillis.detach(); for (LongSamplingCounter counter : mTxTimeMillis) { counter.detach(); @@ -2881,6 +2892,15 @@ public class BatteryStatsImpl extends BatteryStats { } /** + * @return a LongSamplingCounter, measuring time spent in the scan state in + * milliseconds. + */ + @Override + public LongSamplingCounter getScanTimeCounter() { + return mScanTimeMillis; + } + + /** * @return a LongSamplingCounter, measuring time spent in the receive state in * milliseconds. */ @@ -5618,8 +5638,11 @@ public class BatteryStatsImpl extends BatteryStats { noteWifiRadioApWakeupLocked(elapsedRealtime, uptime, uid); } mHistoryCur.states |= HistoryItem.STATE_WIFI_RADIO_ACTIVE_FLAG; + mWifiActiveTimer.startRunningLocked(elapsedRealtime); } else { mHistoryCur.states &= ~HistoryItem.STATE_WIFI_RADIO_ACTIVE_FLAG; + mWifiActiveTimer.stopRunningLocked( + timestampNs / (1000 * 1000)); } if (DEBUG_HISTORY) Slog.v(TAG, "Wifi network active " + active + " to: " + Integer.toHexString(mHistoryCur.states)); @@ -6270,6 +6293,10 @@ public class BatteryStatsImpl extends BatteryStats { return mWifiOnTimer.getTotalTimeLocked(elapsedRealtimeUs, which); } + @Override public long getWifiActiveTime(long elapsedRealtimeUs, int which) { + return mWifiActiveTimer.getTotalTimeLocked(elapsedRealtimeUs, which); + } + @Override public long getGlobalWifiRunningTime(long elapsedRealtimeUs, int which) { return mGlobalWifiRunningTimer.getTotalTimeLocked(elapsedRealtimeUs, which); } @@ -9916,6 +9943,7 @@ public class BatteryStatsImpl extends BatteryStats { mWifiSignalStrengthsTimer[i] = new StopwatchTimer(mClocks, null, -800-i, null, mOnBatteryTimeBase); } + mWifiActiveTimer = new StopwatchTimer(mClocks, null, -900, null, mOnBatteryTimeBase); for (int i=0; i< GnssMetrics.NUM_GPS_SIGNAL_QUALITY_LEVELS; i++) { mGpsSignalQualityTimer[i] = new StopwatchTimer(mClocks, null, -1000-i, null, mOnBatteryTimeBase); @@ -10609,10 +10637,11 @@ public class BatteryStatsImpl extends BatteryStats { mWifiSignalStrengthsTimer[i].reset(false); } mWifiMulticastWakelockTimer.reset(false); + mWifiActiveTimer.reset(false); + mWifiActivity.reset(false); for (int i=0; i< GnssMetrics.NUM_GPS_SIGNAL_QUALITY_LEVELS; i++) { mGpsSignalQualityTimer[i].reset(false); } - mWifiActivity.reset(false); mBluetoothActivity.reset(false); mModemActivity.reset(false); mNumConnectivityChange = mLoadedNumConnectivityChange = mUnpluggedNumConnectivityChange = 0; @@ -10875,6 +10904,7 @@ public class BatteryStatsImpl extends BatteryStats { // Measured in mAms final long txTimeMs = info.getControllerTxTimeMillis(); final long rxTimeMs = info.getControllerRxTimeMillis(); + final long scanTimeMs = info.getControllerScanTimeMillis(); final long idleTimeMs = info.getControllerIdleTimeMillis(); final long totalTimeMs = txTimeMs + rxTimeMs + idleTimeMs; @@ -10887,6 +10917,7 @@ public class BatteryStatsImpl extends BatteryStats { Slog.d(TAG, " Rx Time: " + rxTimeMs + " ms"); Slog.d(TAG, " Idle Time: " + idleTimeMs + " ms"); Slog.d(TAG, " Total Time: " + totalTimeMs + " ms"); + Slog.d(TAG, " Scan Time: " + scanTimeMs + " ms"); } long totalWifiLockTimeMs = 0; @@ -11020,6 +11051,8 @@ public class BatteryStatsImpl extends BatteryStats { mWifiActivity.getRxTimeCounter().addCountLocked(info.getControllerRxTimeMillis()); mWifiActivity.getTxTimeCounters()[0].addCountLocked( info.getControllerTxTimeMillis()); + mWifiActivity.getScanTimeCounter().addCountLocked( + info.getControllerScanTimeMillis()); mWifiActivity.getIdleTimeCounter().addCountLocked( info.getControllerIdleTimeMillis()); @@ -12530,6 +12563,56 @@ public class BatteryStatsImpl extends BatteryStats { return s; } + /*@hide */ + public WifiBatteryStats getWifiBatteryStats() { + WifiBatteryStats s = new WifiBatteryStats(); + final int which = STATS_SINCE_CHARGED; + final long rawRealTime = SystemClock.elapsedRealtime() * 1000; + final ControllerActivityCounter counter = getWifiControllerActivity(); + final long idleTimeMs = counter.getIdleTimeCounter().getCountLocked(which); + final long scanTimeMs = counter.getScanTimeCounter().getCountLocked(which); + final long rxTimeMs = counter.getRxTimeCounter().getCountLocked(which); + final long txTimeMs = counter.getTxTimeCounters()[0].getCountLocked(which); + final long totalControllerActivityTimeMs + = computeBatteryRealtime(SystemClock.elapsedRealtime() * 1000, which) / 1000; + final long sleepTimeMs + = totalControllerActivityTimeMs - (idleTimeMs + rxTimeMs + txTimeMs); + final long energyConsumedMaMs = counter.getPowerCounter().getCountLocked(which); + long numAppScanRequest = 0; + for (int i = 0; i < mUidStats.size(); i++) { + numAppScanRequest += mUidStats.valueAt(i).mWifiScanTimer.getCountLocked(which); + } + long[] timeInStateMs = new long[NUM_WIFI_STATES]; + for (int i=0; i=0) && (mControllerRxTimeMs >=0) && + (mControllerScanTimeMs >=0) && (mControllerIdleTimeMs >=0)); } -} +} \ No newline at end of file -- 2.11.0