From 617f877c06c82584a38f41bb60d836e08c5e3bda Mon Sep 17 00:00:00 2001 From: Dianne Hackborn <> Date: Tue, 31 Mar 2009 15:04:46 -0700 Subject: AI 143800: am: CL 143748 Fix issue #1743326 (More battery stats) Adds stats for: - Number of raw user events that have happened in the system. - Number of times user activity has been reported, dividied by UID and type of activity. - Duration of screen brightness levels in 4 buckets. - Per-UID tracking of who has turned on Wifi and how long we can attribute it being on because of them. Original author: hackbod Merged from: //branches/cupcake/... Automated import of CL 143800 --- core/java/android/os/BatteryStats.java | 245 +++++++++++++--- core/java/android/os/LocalPowerManager.java | 2 + .../com/android/internal/app/IBatteryStats.aidl | 7 +- .../com/android/internal/os/BatteryStatsImpl.java | 308 ++++++++++++++++++++- .../java/com/android/server/HardwareService.java | 19 +- .../com/android/server/PowerManagerService.java | 44 ++- services/java/com/android/server/WifiService.java | 44 +-- .../com/android/server/WindowManagerService.java | 5 + .../com/android/server/am/BatteryStatsService.java | 29 +- 9 files changed, 623 insertions(+), 80 deletions(-) diff --git a/core/java/android/os/BatteryStats.java b/core/java/android/os/BatteryStats.java index c747c43..17594d4 100644 --- a/core/java/android/os/BatteryStats.java +++ b/core/java/android/os/BatteryStats.java @@ -41,18 +41,25 @@ public abstract class BatteryStats implements Parcelable { public static final int SENSOR = 3; /** + * A constant indicating a a wifi turn on timer + * + * {@hide} + */ + public static final int WIFI_TURNED_ON = 4; + + /** * A constant indicating a full wifi lock timer * * {@hide} */ - public static final int FULL_WIFI_LOCK = 4; + public static final int FULL_WIFI_LOCK = 5; /** * A constant indicating a scan wifi lock timer * * {@hide} */ - public static final int SCAN_WIFI_LOCK = 5; + public static final int SCAN_WIFI_LOCK = 6; /** * Include all of the data in the stats, including previously saved data. @@ -77,7 +84,7 @@ public abstract class BatteryStats implements Parcelable { /** * Bump the version on this if the checkin format changes. */ - private static final int BATTERY_STATS_CHECKIN_VERSION = 2; + private static final int BATTERY_STATS_CHECKIN_VERSION = 3; private static final long BYTES_PER_KB = 1024; private static final long BYTES_PER_MB = 1048576; // 1024^2 @@ -91,16 +98,39 @@ public abstract class BatteryStats implements Parcelable { private static final String SENSOR_DATA = "sensor"; private static final String WAKELOCK_DATA = "wakelock"; private static final String NETWORK_DATA = "network"; + private static final String USER_ACTIVITY_DATA = "useract"; private static final String BATTERY_DATA = "battery"; private static final String WIFI_LOCK_DATA = "wifilock"; private static final String MISC_DATA = "misc"; - private static final String SIGNAL_STRENGTH_DATA = "signal"; - private static final String DATA_CONNECTION_DATA = "dataconn"; + private static final String SCREEN_BRIGHTNESS_DATA = "brightness"; + private static final String SIGNAL_STRENGTH_TIME_DATA = "sigtime"; + private static final String SIGNAL_STRENGTH_COUNT_DATA = "sigcnt"; + private static final String DATA_CONNECTION_TIME_DATA = "dconntime"; + private static final String DATA_CONNECTION_COUNT_DATA = "dconncnt"; private final StringBuilder mFormatBuilder = new StringBuilder(8); private final Formatter mFormatter = new Formatter(mFormatBuilder); /** + * State for keeping track of counting information. + */ + public static abstract class Counter { + + /** + * Returns the count associated with this Counter for the + * selected type of statistics. + * + * @param which one of STATS_TOTAL, STATS_LAST, or STATS_CURRENT + */ + public abstract int getCount(int which); + + /** + * Temporary for debugging. + */ + public abstract void logState(Printer pw, String prefix); + } + + /** * State for keeping track of timing information. */ public static abstract class Timer { @@ -184,13 +214,29 @@ public abstract class BatteryStats implements Parcelable { */ public abstract long getTcpBytesSent(int which); + public abstract void noteWifiTurnedOnLocked(); + public abstract void noteWifiTurnedOffLocked(); public abstract void noteFullWifiLockAcquiredLocked(); public abstract void noteFullWifiLockReleasedLocked(); public abstract void noteScanWifiLockAcquiredLocked(); public abstract void noteScanWifiLockReleasedLocked(); + public abstract long getWifiTurnedOnTime(long batteryRealtime, int which); public abstract long getFullWifiLockTime(long batteryRealtime, int which); public abstract long getScanWifiLockTime(long batteryRealtime, int which); + /** + * Note that these must match the constants in android.os.LocalPowerManager. + */ + static final String[] USER_ACTIVITY_TYPES = { + "other", "cheek", "touch", "long_touch", "touch_up", "button", "unknown" + }; + + public static final int NUM_USER_ACTIVITY_TYPES = 7; + + public abstract void noteUserActivityLocked(int type); + public abstract boolean hasUserActivity(); + public abstract int getUserActivityCount(int type, int which); + public static abstract class Sensor { // Magic sensor number for the GPS. public static final int GPS = -10000; @@ -289,6 +335,29 @@ public abstract class BatteryStats implements Parcelable { */ public abstract long getScreenOnTime(long batteryRealtime, int which); + public static final int SCREEN_BRIGHTNESS_DARK = 0; + public static final int SCREEN_BRIGHTNESS_DIM = 1; + public static final int SCREEN_BRIGHTNESS_MEDIUM = 2; + public static final int SCREEN_BRIGHTNESS_LIGHT = 3; + public static final int SCREEN_BRIGHTNESS_BRIGHT = 4; + + static final String[] SCREEN_BRIGHTNESS_NAMES = { + "dark", "dim", "medium", "light", "bright" + }; + + public static final int NUM_SCREEN_BRIGHTNESS_BINS = 5; + + /** + * Returns the time in milliseconds that the screen has been on with + * the given brightness + * + * {@hide} + */ + public abstract long getScreenBrightnessTime(int brightnessBin, + long batteryRealtime, int which); + + public abstract int getInputEventCount(int which); + /** * Returns the time in milliseconds that the phone has been on while the device was * running on battery. @@ -318,6 +387,13 @@ public abstract class BatteryStats implements Parcelable { public abstract long getPhoneSignalStrengthTime(int strengthBin, long batteryRealtime, int which); + /** + * Returns the number of times the phone has entered the given signal strength. + * + * {@hide} + */ + public abstract int getPhoneSignalStrengthCount(int strengthBin, int which); + public static final int DATA_CONNECTION_NONE = 0; public static final int DATA_CONNECTION_GPRS = 1; public static final int DATA_CONNECTION_EDGE = 2; @@ -340,6 +416,14 @@ public abstract class BatteryStats implements Parcelable { long batteryRealtime, int which); /** + * Returns the number of times the phone has entered the given data + * connection type. + * + * {@hide} + */ + public abstract int getPhoneDataConnectionCount(int dataType, int which); + + /** * Returns the time in milliseconds that wifi has been on while the device was * running on battery. * @@ -619,8 +703,8 @@ public abstract class BatteryStats implements Parcelable { // Dump "battery" stat dumpLine(pw, 0 /* uid */, category, BATTERY_DATA, which == STATS_TOTAL ? getStartCount() : "N/A", - whichBatteryUptime / 1000, whichBatteryRealtime / 1000, - totalUptime / 1000, totalRealtime / 1000); + whichBatteryRealtime / 1000, whichBatteryUptime / 1000, + totalRealtime / 1000, totalUptime / 1000); // Calculate total network and wakelock times across all uids. long rxTotal = 0; @@ -657,21 +741,37 @@ public abstract class BatteryStats implements Parcelable { dumpLine(pw, 0 /* uid */, category, MISC_DATA, screenOnTime / 1000, phoneOnTime / 1000, wifiOnTime / 1000, wifiRunningTime / 1000, bluetoothOnTime / 1000, rxTotal, txTotal, - fullWakeLockTimeTotal, partialWakeLockTimeTotal); + fullWakeLockTimeTotal, partialWakeLockTimeTotal, + getInputEventCount(which)); + + // Dump screen brightness stats + Object[] args = new Object[NUM_SCREEN_BRIGHTNESS_BINS]; + for (int i=0; i 0 || tx > 0) dumpLine(pw, uid, category, NETWORK_DATA, rx, tx); - if (fullWifiLockOnTime != 0 || scanWifiLockOnTime != 0) { + if (fullWifiLockOnTime != 0 || scanWifiLockOnTime != 0 + || wifiTurnedOnTime != 0) { dumpLine(pw, uid, category, WIFI_LOCK_DATA, - fullWifiLockOnTime, scanWifiLockOnTime); + fullWifiLockOnTime, scanWifiLockOnTime, wifiTurnedOnTime); } + if (u.hasUserActivity()) { + args = new Object[Uid.NUM_USER_ACTIVITY_TYPES]; + boolean hasData = false; + for (int i=0; i wakelocks = u.getWakelockStats(); if (wakelocks.size() > 0) { for (Map.Entry ent @@ -800,18 +915,19 @@ public abstract class BatteryStats implements Parcelable { final int NU = uidStats.size(); pw.println(prefix - + " Time on battery: " + formatTimeMs(whichBatteryUptime / 1000) - + "(" + formatRatioLocked(whichBatteryUptime, totalRealtime) - + ") uptime, " + + " Time on battery: " + formatTimeMs(whichBatteryRealtime / 1000) + "(" + formatRatioLocked(whichBatteryRealtime, totalRealtime) - + ") realtime"); + + ") realtime, " + + formatTimeMs(whichBatteryUptime / 1000) + + "(" + formatRatioLocked(whichBatteryUptime, totalRealtime) + + ") uptime"); pw.println(prefix - + " Total: " - + formatTimeMs(totalUptime / 1000) - + "uptime, " + + " Total run time: " + formatTimeMs(totalRealtime / 1000) - + "realtime"); + + "realtime, " + + formatTimeMs(totalUptime / 1000) + + "uptime, "); final long screenOnTime = getScreenOnTime(batteryRealtime, which); final long phoneOnTime = getPhoneOnTime(batteryRealtime, which); @@ -821,15 +937,28 @@ public abstract class BatteryStats implements Parcelable { pw.println(prefix + " Screen on: " + formatTimeMs(screenOnTime / 1000) + "(" + formatRatioLocked(screenOnTime, whichBatteryRealtime) - + "), Phone on: " + formatTimeMs(phoneOnTime / 1000) - + "(" + formatRatioLocked(phoneOnTime, whichBatteryRealtime)); - pw.println(prefix - + " Wifi on: " + formatTimeMs(wifiOnTime / 1000) - + "(" + formatRatioLocked(wifiOnTime, whichBatteryRealtime) - + "), Wifi running: " + formatTimeMs(wifiRunningTime / 1000) - + "(" + formatRatioLocked(wifiRunningTime, whichBatteryRealtime) - + "), Bluetooth on: " + formatTimeMs(bluetoothOnTime / 1000) - + "(" + formatRatioLocked(bluetoothOnTime, whichBatteryRealtime)+ ")"); + + "), Input events: " + getInputEventCount(which) + + ", Active phone call: " + formatTimeMs(phoneOnTime / 1000) + + "(" + formatRatioLocked(phoneOnTime, whichBatteryRealtime) + ")"); + sb.setLength(0); + sb.append(" Screen brightnesses: "); + boolean didOne = false; + for (int i=0; i unpluggables, Parcel in) { + mPluggedCount = mCount = in.readInt(); + mLoadedCount = in.readInt(); + mLastCount = in.readInt(); + mUnpluggedCount = in.readInt(); + unpluggables.add(this); + } + + Counter(ArrayList unpluggables) { + unpluggables.add(this); + } + + public void writeToParcel(Parcel out) { + out.writeInt(mCount); + out.writeInt(mLoadedCount); + out.writeInt(mLastCount); + out.writeInt(mUnpluggedCount); + } + + public void unplug(long batteryUptime, long batteryRealtime) { + mUnpluggedCount = mCount = mPluggedCount; + } + + public void plug(long batteryUptime, long batteryRealtime) { + mPluggedCount = mCount; + } + + /** + * Writes a possibly null Counter to a Parcel. + * + * @param out the Parcel to be written to. + * @param counter a Counter, or null. + */ + public static void writeCounterToParcel(Parcel out, Counter counter) { + if (counter == null) { + out.writeInt(0); // indicates null + return; + } + out.writeInt(1); // indicates non-null + + counter.writeToParcel(out); + } + + @Override + public int getCount(int which) { + int val; + if (which == STATS_LAST) { + val = mLastCount; + } else { + val = mCount; + if (which == STATS_UNPLUGGED) { + val -= mUnpluggedCount; + } else if (which != STATS_TOTAL) { + val -= mLoadedCount; + } + } + + return val; + } + + public void logState(Printer pw, String prefix) { + pw.println(prefix + "mCount=" + mCount + + " mLoadedCount=" + mLoadedCount + " mLastCount=" + mLastCount + + " mUnpluggedCount=" + mUnpluggedCount + + " mPluggedCount=" + mPluggedCount); + } + + void stepLocked() { + mCount++; + } + + void writeSummaryFromParcelLocked(Parcel out) { + out.writeInt(mCount); + out.writeInt(mCount - mLoadedCount); + } + + void readSummaryFromParcelLocked(Parcel in) { + mCount = mLoadedCount = in.readInt(); + mLastCount = in.readInt(); + mUnpluggedCount = mPluggedCount = mCount; + } + } + + /** * State for keeping track of timing information. */ public static final class Timer extends BatteryStats.Timer implements Unpluggable { @@ -469,6 +568,9 @@ public final class BatteryStatsImpl extends BatteryStats { if (!mScreenOn) { mScreenOn = true; mScreenOnTimer.startRunningLocked(this); + if (mScreenBrightnessBin >= 0) { + mScreenBrightnessTimer[mScreenBrightnessBin].startRunningLocked(this); + } } } @@ -476,6 +578,36 @@ public final class BatteryStatsImpl extends BatteryStats { if (mScreenOn) { mScreenOn = false; mScreenOnTimer.stopRunningLocked(this); + if (mScreenBrightnessBin >= 0) { + mScreenBrightnessTimer[mScreenBrightnessBin].stopRunningLocked(this); + } + } + } + + public void noteScreenBrightnessLocked(int brightness) { + // Bin the brightness. + int bin = brightness / (256/NUM_SCREEN_BRIGHTNESS_BINS); + if (bin < 0) bin = 0; + else if (bin >= NUM_SCREEN_BRIGHTNESS_BINS) bin = NUM_SCREEN_BRIGHTNESS_BINS-1; + if (mScreenBrightnessBin != bin) { + if (mScreenOn) { + if (mScreenBrightnessBin >= 0) { + mScreenBrightnessTimer[mScreenBrightnessBin].stopRunningLocked(this); + } + mScreenBrightnessTimer[bin].startRunningLocked(this); + } + mScreenBrightnessBin = bin; + } + } + + public void noteInputEventLocked() { + mInputEventCounter.stepLocked(); + } + + public void noteUserActivityLocked(int uid, int event) { + Uid u = mUidStats.get(uid); + if (u != null) { + u.noteUserActivityLocked(event); } } @@ -537,18 +669,38 @@ public final class BatteryStatsImpl extends BatteryStats { } } - public void noteWifiOnLocked() { + public void noteWifiOnLocked(int uid) { if (!mWifiOn) { mWifiOn = true; mWifiOnTimer.startRunningLocked(this); } + if (mWifiOnUid != uid) { + if (mWifiOnUid >= 0) { + Uid u = mUidStats.get(mWifiOnUid); + if (u != null) { + u.noteWifiTurnedOffLocked(); + } + } + mWifiOnUid = uid; + Uid u = mUidStats.get(uid); + if (u != null) { + u.noteWifiTurnedOnLocked(); + } + } } - public void noteWifiOffLocked() { + public void noteWifiOffLocked(int uid) { if (mWifiOn) { mWifiOn = false; mWifiOnTimer.stopRunningLocked(this); } + if (mWifiOnUid >= 0) { + Uid u = mUidStats.get(mWifiOnUid); + if (u != null) { + u.noteWifiTurnedOffLocked(); + } + mWifiOnUid = -1; + } } public void noteWifiRunningLocked() { @@ -611,6 +763,16 @@ public final class BatteryStatsImpl extends BatteryStats { return mScreenOnTimer.getTotalTime(batteryRealtime, which); } + @Override public long getScreenBrightnessTime(int brightnessBin, + long batteryRealtime, int which) { + return mScreenBrightnessTimer[brightnessBin].getTotalTime( + batteryRealtime, which); + } + + @Override public int getInputEventCount(int which) { + return mInputEventCounter.getCount(which); + } + @Override public long getPhoneOnTime(long batteryRealtime, int which) { return mPhoneOnTimer.getTotalTime(batteryRealtime, which); } @@ -621,12 +783,20 @@ public final class BatteryStatsImpl extends BatteryStats { batteryRealtime, which); } + @Override public int getPhoneSignalStrengthCount(int dataType, int which) { + return mPhoneDataConnectionsTimer[dataType].getCount(which); + } + @Override public long getPhoneDataConnectionTime(int dataType, long batteryRealtime, int which) { return mPhoneDataConnectionsTimer[dataType].getTotalTime( batteryRealtime, which); } + @Override public int getPhoneDataConnectionCount(int dataType, int which) { + return mPhoneDataConnectionsTimer[dataType].getCount(which); + } + @Override public long getWifiOnTime(long batteryRealtime, int which) { return mWifiOnTimer.getTotalTime(batteryRealtime, which); } @@ -665,12 +835,17 @@ public final class BatteryStatsImpl extends BatteryStats { long mStartedTcpBytesReceived = -1; long mStartedTcpBytesSent = -1; + boolean mWifiTurnedOn; + Timer mWifiTurnedOnTimer; + boolean mFullWifiLockOut; Timer mFullWifiLockTimer; boolean mScanWifiLockOut; Timer mScanWifiLockTimer; + Counter[] mUserActivityCounters; + /** * The statistics we have collected for this uid's wake locks. */ @@ -693,6 +868,7 @@ public final class BatteryStatsImpl extends BatteryStats { public Uid(int uid) { mUid = uid; + mWifiTurnedOnTimer = new Timer(WIFI_TURNED_ON, null, mUnpluggables); mFullWifiLockTimer = new Timer(FULL_WIFI_LOCK, null, mUnpluggables); mScanWifiLockTimer = new Timer(SCAN_WIFI_LOCK, null, mUnpluggables); } @@ -755,6 +931,22 @@ public final class BatteryStatsImpl extends BatteryStats { } @Override + public void noteWifiTurnedOnLocked() { + if (!mWifiTurnedOn) { + mWifiTurnedOn = true; + mWifiTurnedOnTimer.startRunningLocked(BatteryStatsImpl.this); + } + } + + @Override + public void noteWifiTurnedOffLocked() { + if (mWifiTurnedOn) { + mWifiTurnedOn = false; + mWifiTurnedOnTimer.stopRunningLocked(BatteryStatsImpl.this); + } + } + + @Override public void noteFullWifiLockAcquiredLocked() { if (!mFullWifiLockOut) { mFullWifiLockOut = true; @@ -785,6 +977,12 @@ public final class BatteryStatsImpl extends BatteryStats { mScanWifiLockTimer.stopRunningLocked(BatteryStatsImpl.this); } } + + @Override + public long getWifiTurnedOnTime(long batteryRealtime, int which) { + return mWifiTurnedOnTimer.getTotalTime(batteryRealtime, which); + } + @Override public long getFullWifiLockTime(long batteryRealtime, int which) { return mFullWifiLockTimer.getTotalTime(batteryRealtime, which); @@ -795,6 +993,36 @@ public final class BatteryStatsImpl extends BatteryStats { return mScanWifiLockTimer.getTotalTime(batteryRealtime, which); } + @Override + public void noteUserActivityLocked(int type) { + if (mUserActivityCounters == null) { + initUserActivityLocked(); + } + if (type < 0) type = 0; + else if (type >= NUM_USER_ACTIVITY_TYPES) type = NUM_USER_ACTIVITY_TYPES-1; + mUserActivityCounters[type].stepLocked(); + } + + @Override + public boolean hasUserActivity() { + return mUserActivityCounters != null; + } + + @Override + public int getUserActivityCount(int type, int which) { + if (mUserActivityCounters == null) { + return 0; + } + return mUserActivityCounters[type].getCount(which); + } + + void initUserActivityLocked() { + mUserActivityCounters = new Counter[NUM_USER_ACTIVITY_TYPES]; + for (int i=0; i= 0 ? (NetStat.getUidTxBytes(mUid) - mStartedTcpBytesSent) : 0); @@ -835,8 +1063,17 @@ public final class BatteryStatsImpl extends BatteryStats { out.writeLong(computeCurrentTcpBytesSent()); out.writeLong(mTcpBytesReceivedAtLastUnplug); out.writeLong(mTcpBytesSentAtLastUnplug); + mWifiTurnedOnTimer.writeToParcel(out, batteryRealtime); mFullWifiLockTimer.writeToParcel(out, batteryRealtime); mScanWifiLockTimer.writeToParcel(out, batteryRealtime); + if (mUserActivityCounters == null) { + out.writeInt(0); + } else { + out.writeInt(1); + for (int i=0; i unpluggables, Parcel in) { @@ -882,10 +1119,20 @@ public final class BatteryStatsImpl extends BatteryStats { mCurrentTcpBytesSent = in.readLong(); mTcpBytesReceivedAtLastUnplug = in.readLong(); mTcpBytesSentAtLastUnplug = in.readLong(); + mWifiTurnedOn = false; + mWifiTurnedOnTimer = new Timer(WIFI_TURNED_ON, null, mUnpluggables, in); mFullWifiLockOut = false; mFullWifiLockTimer = new Timer(FULL_WIFI_LOCK, null, mUnpluggables, in); mScanWifiLockOut = false; mScanWifiLockTimer = new Timer(SCAN_WIFI_LOCK, null, mUnpluggables, in); + if (in.readInt() == 0) { + mUserActivityCounters = null; + } else { + mUserActivityCounters = new Counter[NUM_USER_ACTIVITY_TYPES]; + for (int i=0; i 0) { @@ -2265,13 +2545,17 @@ public final class BatteryStatsImpl extends BatteryStats { mBatteryLastRealtime = in.readLong(); mScreenOn = false; mScreenOnTimer = new Timer(-1, null, mUnpluggables, in); + for (int i=0; i 1.0f) ratio = 1.0f; if ((newState & SCREEN_ON_BIT) == 0) { - int steps; if ((oldState & SCREEN_BRIGHT_BIT) != 0) { // was bright steps = ANIM_STEPS; @@ -1471,10 +1474,8 @@ class PowerManagerService extends IPowerManager.Stub implements LocalPowerManage // was dim steps = (int)(ANIM_STEPS*ratio*scale); } - mScreenBrightness.setTargetLocked(Power.BRIGHTNESS_OFF, - steps, INITIAL_SCREEN_BRIGHTNESS, nominalCurrentValue); + brightness = Power.BRIGHTNESS_OFF; } else { - int steps; if ((oldState & SCREEN_ON_BIT) != 0) { // was bright steps = (int)(ANIM_STEPS*(1.0f-ratio)*scale); @@ -1490,13 +1491,19 @@ class PowerManagerService extends IPowerManager.Stub implements LocalPowerManage // will then count going dim as turning off. mScreenOffTime = SystemClock.elapsedRealtime(); } - mScreenBrightness.setTargetLocked(Power.BRIGHTNESS_DIM, - steps, INITIAL_SCREEN_BRIGHTNESS, nominalCurrentValue); + brightness = Power.BRIGHTNESS_DIM; } - } else { - mScreenBrightness.setTargetLocked(preferredBrightness, - ANIM_STEPS, INITIAL_SCREEN_BRIGHTNESS, nominalCurrentValue); } + long identity = Binder.clearCallingIdentity(); + try { + mBatteryStats.noteScreenBrightness(brightness); + } catch (RemoteException e) { + // Nothing interesting to do. + } finally { + Binder.restoreCallingIdentity(identity); + } + mScreenBrightness.setTargetLocked(brightness, + steps, INITIAL_SCREEN_BRIGHTNESS, nominalCurrentValue); startAnimation = true; } else { if ((newState & SCREEN_BRIGHT_BIT) == 0) { @@ -1735,6 +1742,16 @@ class PowerManagerService extends IPowerManager.Stub implements LocalPowerManage mUserState |= SCREEN_BRIGHT; } + int uid = Binder.getCallingUid(); + long ident = Binder.clearCallingIdentity(); + try { + mBatteryStats.noteUserActivity(uid, eventType); + } catch (RemoteException e) { + // Ignore + } finally { + Binder.restoreCallingIdentity(ident); + } + reactivateWakeLocksLocked(); mWakeLockState = mLocks.gatherState(); setPowerState(mUserState | mWakeLockState, noChangeLights, true); @@ -1951,6 +1968,15 @@ class PowerManagerService extends IPowerManager.Stub implements LocalPowerManage synchronized (mLocks) { Log.d(TAG, "system ready!"); mDoneBooting = true; + long identity = Binder.clearCallingIdentity(); + try { + mBatteryStats.noteScreenBrightness(getPreferredBrightness()); + mBatteryStats.noteScreenOn(); + } catch (RemoteException e) { + // Nothing interesting to do. + } finally { + Binder.restoreCallingIdentity(identity); + } userActivity(SystemClock.uptimeMillis(), false, BUTTON_EVENT, true); updateWakeLockLocked(); mLocks.notifyAll(); diff --git a/services/java/com/android/server/WifiService.java b/services/java/com/android/server/WifiService.java index 8e1d053..54e77f0 100644 --- a/services/java/com/android/server/WifiService.java +++ b/services/java/com/android/server/WifiService.java @@ -47,6 +47,7 @@ import android.os.IBinder; import android.os.Looper; import android.os.Message; import android.os.PowerManager; +import android.os.Process; import android.os.RemoteException; import android.provider.Settings; import android.util.Log; @@ -167,6 +168,11 @@ public class WifiService extends IWifiManager.Stub { private char[] mScanResultBuffer; private boolean mNeedReconfig; + /* + * Last UID that asked to enable WIFI. + */ + private int mLastEnableUid = Process.myUid(); + /** * Number of allowed radio frequency channels in various regulatory domains. * This list is sufficient for 802.11b/g networks (2.4GHz range). @@ -239,7 +245,7 @@ public class WifiService extends IWifiManager.Stub { }, new IntentFilter(Intent.ACTION_AIRPLANE_MODE_CHANGED)); - setWifiEnabledBlocking(wifiEnabled, false); + setWifiEnabledBlocking(wifiEnabled, false, Process.myUid()); } /** @@ -455,7 +461,8 @@ public class WifiService extends IWifiManager.Stub { synchronized (mWifiHandler) { sWakeLock.acquire(); - sendEnableMessage(enable, true); + mLastEnableUid = Binder.getCallingUid(); + sendEnableMessage(enable, true, Binder.getCallingUid()); } return true; @@ -465,10 +472,11 @@ public class WifiService extends IWifiManager.Stub { * Enables/disables Wi-Fi synchronously. * @param enable {@code true} to turn Wi-Fi on, {@code false} to turn it off. * @param persist {@code true} if the setting should be persisted. + * @param uid The UID of the process making the request. * @return {@code true} if the operation succeeds (or if the existing state * is the same as the requested state) */ - private boolean setWifiEnabledBlocking(boolean enable, boolean persist) { + private boolean setWifiEnabledBlocking(boolean enable, boolean persist, int uid) { final int eventualWifiState = enable ? WIFI_STATE_ENABLED : WIFI_STATE_DISABLED; if (mWifiState == eventualWifiState) { @@ -478,18 +486,18 @@ public class WifiService extends IWifiManager.Stub { return false; } - setWifiEnabledState(enable ? WIFI_STATE_ENABLING : WIFI_STATE_DISABLING); + setWifiEnabledState(enable ? WIFI_STATE_ENABLING : WIFI_STATE_DISABLING, uid); if (enable) { if (!WifiNative.loadDriver()) { Log.e(TAG, "Failed to load Wi-Fi driver."); - setWifiEnabledState(WIFI_STATE_UNKNOWN); + setWifiEnabledState(WIFI_STATE_UNKNOWN, uid); return false; } if (!WifiNative.startSupplicant()) { WifiNative.unloadDriver(); Log.e(TAG, "Failed to start supplicant daemon."); - setWifiEnabledState(WIFI_STATE_UNKNOWN); + setWifiEnabledState(WIFI_STATE_UNKNOWN, uid); return false; } registerForBroadcasts(); @@ -503,7 +511,7 @@ public class WifiService extends IWifiManager.Stub { boolean failedToStopSupplicantOrUnloadDriver = false; if (!WifiNative.stopSupplicant()) { Log.e(TAG, "Failed to stop supplicant daemon."); - setWifiEnabledState(WIFI_STATE_UNKNOWN); + setWifiEnabledState(WIFI_STATE_UNKNOWN, uid); failedToStopSupplicantOrUnloadDriver = true; } @@ -513,7 +521,7 @@ public class WifiService extends IWifiManager.Stub { if (!WifiNative.unloadDriver()) { Log.e(TAG, "Failed to unload Wi-Fi driver."); if (!failedToStopSupplicantOrUnloadDriver) { - setWifiEnabledState(WIFI_STATE_UNKNOWN); + setWifiEnabledState(WIFI_STATE_UNKNOWN, uid); failedToStopSupplicantOrUnloadDriver = true; } } @@ -527,7 +535,7 @@ public class WifiService extends IWifiManager.Stub { if (persist) { persistWifiEnabled(enable); } - setWifiEnabledState(eventualWifiState); + setWifiEnabledState(eventualWifiState, uid); /* * Initialize the hidden networks state and the number of allowed @@ -541,15 +549,15 @@ public class WifiService extends IWifiManager.Stub { return true; } - private void setWifiEnabledState(int wifiState) { + private void setWifiEnabledState(int wifiState, int uid) { final int previousWifiState = mWifiState; long ident = Binder.clearCallingIdentity(); try { if (wifiState == WIFI_STATE_ENABLED) { - mBatteryStats.noteWifiOn(); + mBatteryStats.noteWifiOn(uid); } else if (wifiState == WIFI_STATE_DISABLED) { - mBatteryStats.noteWifiOff(); + mBatteryStats.noteWifiOff(uid); } } catch (RemoteException e) { } finally { @@ -1571,10 +1579,10 @@ public class WifiService extends IWifiManager.Stub { } }; - private void sendEnableMessage(boolean enable, boolean persist) { + private void sendEnableMessage(boolean enable, boolean persist, int uid) { Message msg = Message.obtain(mWifiHandler, (enable ? MESSAGE_ENABLE_WIFI : MESSAGE_DISABLE_WIFI), - (persist ? 1 : 0), 0); + (persist ? 1 : 0), uid); msg.sendToTarget(); } @@ -1602,7 +1610,7 @@ public class WifiService extends IWifiManager.Stub { if (wifiShouldBeEnabled) { if (wifiShouldBeStarted) { sWakeLock.acquire(); - sendEnableMessage(true, false); + sendEnableMessage(true, false, mLastEnableUid); sWakeLock.acquire(); sendStartMessage(strongestLockMode == WifiManager.WIFI_MODE_SCAN_ONLY); } else { @@ -1626,7 +1634,7 @@ public class WifiService extends IWifiManager.Stub { } } else { sWakeLock.acquire(); - sendEnableMessage(false, false); + sendEnableMessage(false, false, mLastEnableUid); } } } @@ -1671,7 +1679,7 @@ public class WifiService extends IWifiManager.Stub { switch (msg.what) { case MESSAGE_ENABLE_WIFI: - setWifiEnabledBlocking(true, msg.arg1 == 1); + setWifiEnabledBlocking(true, msg.arg1 == 1, msg.arg2); sWakeLock.release(); break; @@ -1684,7 +1692,7 @@ public class WifiService extends IWifiManager.Stub { case MESSAGE_DISABLE_WIFI: // a non-zero msg.arg1 value means the "enabled" setting // should be persisted - setWifiEnabledBlocking(false, msg.arg1 == 1); + setWifiEnabledBlocking(false, msg.arg1 == 1, msg.arg2); sWakeLock.release(); break; diff --git a/services/java/com/android/server/WindowManagerService.java b/services/java/com/android/server/WindowManagerService.java index 2e16157..270d15f 100644 --- a/services/java/com/android/server/WindowManagerService.java +++ b/services/java/com/android/server/WindowManagerService.java @@ -5085,6 +5085,11 @@ public class WindowManagerService extends IWindowManager.Stub implements Watchdo } else { eventType = LocalPowerManager.OTHER_EVENT; } + try { + mBatteryStats.noteInputEvent(); + } catch (RemoteException e) { + // Ignore + } mPowerManager.userActivity(curTime, false, eventType); switch (ev.classType) { case RawInputEvent.CLASS_KEYBOARD: diff --git a/services/java/com/android/server/am/BatteryStatsService.java b/services/java/com/android/server/am/BatteryStatsService.java index 2192e06..9ad994c 100644 --- a/services/java/com/android/server/am/BatteryStatsService.java +++ b/services/java/com/android/server/am/BatteryStatsService.java @@ -129,6 +129,13 @@ public final class BatteryStatsService extends IBatteryStats.Stub { } } + public void noteScreenBrightness(int brightness) { + enforceCallingPermission(); + synchronized (mStats) { + mStats.noteScreenBrightnessLocked(brightness); + } + } + public void noteScreenOff() { enforceCallingPermission(); synchronized (mStats) { @@ -136,6 +143,20 @@ public final class BatteryStatsService extends IBatteryStats.Stub { } } + public void noteInputEvent() { + enforceCallingPermission(); + synchronized (mStats) { + mStats.noteInputEventLocked(); + } + } + + public void noteUserActivity(int uid, int event) { + enforceCallingPermission(); + synchronized (mStats) { + mStats.noteUserActivityLocked(uid, event); + } + } + public void notePhoneOn() { enforceCallingPermission(); synchronized (mStats) { @@ -164,17 +185,17 @@ public final class BatteryStatsService extends IBatteryStats.Stub { } } - public void noteWifiOn() { + public void noteWifiOn(int uid) { enforceCallingPermission(); synchronized (mStats) { - mStats.noteWifiOnLocked(); + mStats.noteWifiOnLocked(uid); } } - public void noteWifiOff() { + public void noteWifiOff(int uid) { enforceCallingPermission(); synchronized (mStats) { - mStats.noteWifiOffLocked(); + mStats.noteWifiOffLocked(uid); } } -- cgit v1.1