public static interface Callbacks {
public void onRunningStateChanged(boolean running);
public void onPackageListChanged();
+ public void onRebuildComplete(ArrayList<AppEntry> apps);
public void onPackageIconChanged();
public void onPackageSizeChanged(String packageName);
public void onAllSizesComputed();
long mCurId = 1;
String mCurComputingSizePkg;
+ // Rebuilding of app list. Synchronized on mRebuildSync.
+ final Object mRebuildSync = new Object();
+ boolean mRebuildRequested;
+ boolean mRebuildAsync;
+ AppFilter mRebuildFilter;
+ Comparator<AppEntry> mRebuildComparator;
+ ArrayList<AppEntry> mRebuildResult;
+
/**
* Receives notifications when applications are added/removed.
*/
}
class MainHandler extends Handler {
- static final int MSG_PACKAGE_LIST_CHANGED = 1;
- static final int MSG_PACKAGE_ICON_CHANGED = 2;
+ static final int MSG_REBUILD_COMPLETE = 1;
+ static final int MSG_PACKAGE_LIST_CHANGED = 2;
+ static final int MSG_PACKAGE_ICON_CHANGED = 3;
static final int MSG_PACKAGE_SIZE_CHANGED = 4;
static final int MSG_ALL_SIZES_COMPUTED = 5;
static final int MSG_RUNNING_STATE_CHANGED = 6;
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
+ case MSG_REBUILD_COMPLETE: {
+ if (mCurCallbacks != null) {
+ mCurCallbacks.onRebuildComplete((ArrayList<AppEntry>)msg.obj);
+ }
+ } break;
case MSG_PACKAGE_LIST_CHANGED: {
if (mCurCallbacks != null) {
mCurCallbacks.onPackageListChanged();
// Creates a new list of app entries with the given filter and comparator.
ArrayList<AppEntry> rebuild(AppFilter filter, Comparator<AppEntry> comparator) {
- ArrayList<AppEntry> filteredApps = new ArrayList<AppEntry>();
+ synchronized (mRebuildSync) {
+ mRebuildRequested = true;
+ mRebuildAsync = false;
+ mRebuildFilter = filter;
+ mRebuildComparator = comparator;
+ mRebuildResult = null;
+ if (!mBackgroundHandler.hasMessages(BackgroundHandler.MSG_REBUILD_LIST)) {
+ mBackgroundHandler.sendEmptyMessage(BackgroundHandler.MSG_REBUILD_LIST);
+ }
+
+ // We will wait for .25s for the list to be built.
+ long waitend = SystemClock.uptimeMillis()+250;
+
+ while (mRebuildResult == null) {
+ long now = SystemClock.uptimeMillis();
+ if (now >= waitend) {
+ break;
+ }
+ try {
+ mRebuildSync.wait(waitend - now);
+ } catch (InterruptedException e) {
+ }
+ }
+
+ mRebuildAsync = true;
+
+ return mRebuildResult;
+ }
+ }
+
+ void handleRebuildList() {
+ AppFilter filter;
+ Comparator<AppEntry> comparator;
+ synchronized (mRebuildSync) {
+ if (!mRebuildRequested) {
+ return;
+ }
+
+ filter = mRebuildFilter;
+ comparator = mRebuildComparator;
+ mRebuildRequested = false;
+ mRebuildFilter = null;
+ mRebuildComparator = null;
+ }
+
+ Process.setThreadPriority(Process.THREAD_PRIORITY_FOREGROUND);
+
+ List<ApplicationInfo> apps;
synchronized (mEntriesMap) {
- if (DEBUG) Log.i(TAG, "Rebuilding...");
- for (int i=0; i<mApplications.size(); i++) {
- ApplicationInfo info = mApplications.get(i);
- if (filter == null || filter.filterApp(info)) {
+ apps = new ArrayList<ApplicationInfo>(mApplications);
+ }
+
+ ArrayList<AppEntry> filteredApps = new ArrayList<AppEntry>();
+ if (DEBUG) Log.i(TAG, "Rebuilding...");
+ for (int i=0; i<apps.size(); i++) {
+ ApplicationInfo info = apps.get(i);
+ if (filter == null || filter.filterApp(info)) {
+ synchronized (mEntriesMap) {
AppEntry entry = getEntryLocked(info);
if (DEBUG) Log.i(TAG, "Using " + info.packageName + ": " + entry);
filteredApps.add(entry);
}
}
}
+
Collections.sort(filteredApps, comparator);
- return filteredApps;
+
+ synchronized (mRebuildSync) {
+ if (!mRebuildRequested) {
+ if (!mRebuildAsync) {
+ mRebuildResult = filteredApps;
+ mRebuildSync.notifyAll();
+ } else {
+ if (!mMainHandler.hasMessages(MainHandler.MSG_REBUILD_COMPLETE)) {
+ Message msg = mMainHandler.obtainMessage(
+ MainHandler.MSG_REBUILD_COMPLETE, filteredApps);
+ mMainHandler.sendMessage(msg);
+ }
+ }
+ }
+ }
+
+ Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
}
AppEntry getEntry(String packageName) {
final HandlerThread mThread;
final BackgroundHandler mBackgroundHandler;
class BackgroundHandler extends Handler {
- static final int MSG_LOAD_ENTRIES = 1;
- static final int MSG_LOAD_ICONS = 2;
- static final int MSG_LOAD_SIZES = 3;
+ static final int MSG_REBUILD_LIST = 1;
+ static final int MSG_LOAD_ENTRIES = 2;
+ static final int MSG_LOAD_ICONS = 3;
+ static final int MSG_LOAD_SIZES = 4;
boolean mRunning;
@Override
public void handleMessage(Message msg) {
+ // Always try rebuilding list first thing, if needed.
+ handleRebuildList();
+
switch (msg.what) {
+ case MSG_REBUILD_LIST: {
+ } break;
case MSG_LOAD_ENTRIES: {
int numDone = 0;
synchronized (mEntriesMap) {
import android.view.View;
public class BatteryHistoryChart extends View {
+ static final int CHART_DATA_X_MASK = 0x0000ffff;
+ static final int CHART_DATA_BIN_MASK = 0xffff0000;
+ static final int CHART_DATA_BIN_SHIFT = 16;
+
+ static class ChartData {
+ int[] mColors;
+ Paint[] mPaints;
+
+ int mNumTicks;
+ int[] mTicks;
+ int mLastBin;
+
+ void setColors(int[] colors) {
+ mColors = colors;
+ mPaints = new Paint[colors.length];
+ for (int i=0; i<colors.length; i++) {
+ mPaints[i] = new Paint();
+ mPaints[i].setColor(colors[i]);
+ mPaints[i].setStyle(Paint.Style.FILL);
+ }
+ }
+
+ void init(int width) {
+ if (width > 0) {
+ mTicks = new int[width+2];
+ } else {
+ mTicks = null;
+ }
+ mNumTicks = 0;
+ mLastBin = 0;
+ }
+
+ void addTick(int x, int bin) {
+ if (bin != mLastBin) {
+ mTicks[mNumTicks] = x | bin << CHART_DATA_BIN_SHIFT;
+ mNumTicks++;
+ mLastBin = bin;
+ }
+ }
+
+ void finish(int width) {
+ if (mLastBin != 0) {
+ addTick(width, 0);
+ }
+ }
+
+ void draw(Canvas canvas, int top, int height) {
+ int lastBin=0, lastX=0;
+ int bottom = top + height;
+ for (int i=0; i<mNumTicks; i++) {
+ int tick = mTicks[i];
+ int x = tick&CHART_DATA_X_MASK;
+ int bin = (tick&CHART_DATA_BIN_MASK) >> CHART_DATA_BIN_SHIFT;
+ if (lastBin != 0) {
+ canvas.drawRect(lastX, top, x, bottom, mPaints[lastBin]);
+ }
+ lastBin = bin;
+ lastX = x;
+ }
+
+ }
+ }
+
static final int SANS = 1;
static final int SERIF = 2;
static final int MONOSPACE = 3;
static final int BATTERY_WARN = 29;
static final int BATTERY_CRITICAL = 14;
- // First value if for phone off; sirst value is "scanning"; following values
+ // First value if for phone off; first value is "scanning"; following values
// are battery stats signal strength buckets.
static final int NUM_PHONE_SIGNALS = 7;
final Paint mGpsOnPaint = new Paint();
final Paint mWifiRunningPaint = new Paint();
final Paint mWakeLockPaint = new Paint();
- final Paint[] mPhoneSignalPaints = new Paint[NUM_PHONE_SIGNALS];
- final int[] mPhoneSignalColors = new int[] {
- 0x00000000, 0xffa00000, 0xffa0a000, 0xff808020,
- 0xff808040, 0xff808060, 0xff008000
- };
+ final ChartData mPhoneSignalChart = new ChartData();
final TextPaint mTextPaint = new TextPaint(Paint.ANTI_ALIAS_FLAG);
final Path mBatLevelPath = new Path();
int mLevelOffset;
int mLevelTop;
int mLevelBottom;
- static final int PHONE_SIGNAL_X_MASK = 0x0000ffff;
- static final int PHONE_SIGNAL_BIN_MASK = 0xffff0000;
- static final int PHONE_SIGNAL_BIN_SHIFT = 16;
- int mNumPhoneSignalTicks;
- int[] mPhoneSignalTicks;
+ static final int PHONE_SIGNAL_X_MASK = CHART_DATA_X_MASK;
+ static final int PHONE_SIGNAL_BIN_MASK = CHART_DATA_BIN_MASK;
+ static final int PHONE_SIGNAL_BIN_SHIFT = CHART_DATA_BIN_SHIFT;
int mNumHist;
- BatteryStats.HistoryItem mHistFirst;
long mHistStart;
long mHistEnd;
int mBatLow;
mBatteryCriticalPaint.setStyle(Paint.Style.STROKE);
mChargingPaint.setARGB(255, 0, 128, 0);
mChargingPaint.setStyle(Paint.Style.STROKE);
- mScreenOnPaint.setARGB(255, 0, 0, 255);
mScreenOnPaint.setStyle(Paint.Style.STROKE);
- mGpsOnPaint.setARGB(255, 0, 0, 255);
mGpsOnPaint.setStyle(Paint.Style.STROKE);
- mWifiRunningPaint.setARGB(255, 0, 0, 255);
mWifiRunningPaint.setStyle(Paint.Style.STROKE);
- mWakeLockPaint.setARGB(255, 0, 0, 255);
mWakeLockPaint.setStyle(Paint.Style.STROKE);
- for (int i=0; i<NUM_PHONE_SIGNALS; i++) {
- mPhoneSignalPaints[i] = new Paint();
- mPhoneSignalPaints[i].setColor(mPhoneSignalColors[i]);
- mPhoneSignalPaints[i].setStyle(Paint.Style.FILL);
- }
+ mPhoneSignalChart.setColors(new int[] {
+ 0x00000000, 0xffa00000, 0xffa0a000, 0xff808020,
+ 0xff808040, 0xff808060, 0xff008000
+ });
mTextPaint.density = getResources().getDisplayMetrics().density;
mTextPaint.setCompatibilityScaling(
mWakeLockLabel = getContext().getString(R.string.battery_stats_wake_lock_label);
mPhoneSignalLabel = getContext().getString(R.string.battery_stats_phone_signal_label);
- BatteryStats.HistoryItem rec = stats.getHistory();
- mHistFirst = null;
int pos = 0;
int lastInteresting = 0;
byte lastLevel = -1;
mBatLow = 0;
mBatHigh = 100;
int aggrStates = 0;
- while (rec != null) {
- pos++;
- if (rec.cmd == HistoryItem.CMD_UPDATE) {
- if (mHistFirst == null) {
- mHistFirst = rec;
- mHistStart = rec.time;
- }
- if (rec.batteryLevel != lastLevel || pos == 1) {
- lastLevel = rec.batteryLevel;
- lastInteresting = pos;
- mHistEnd = rec.time;
+ boolean first = true;
+ if (stats.startIteratingHistoryLocked()) {
+ final HistoryItem rec = new HistoryItem();
+ while (stats.getNextHistoryLocked(rec)) {
+ pos++;
+ if (rec.cmd == HistoryItem.CMD_UPDATE) {
+ if (first) {
+ first = false;
+ mHistStart = rec.time;
+ }
+ if (rec.batteryLevel != lastLevel || pos == 1) {
+ lastLevel = rec.batteryLevel;
+ lastInteresting = pos;
+ mHistEnd = rec.time;
+ }
+ aggrStates |= rec.states;
}
- aggrStates |= rec.states;
}
- rec = rec.next;
}
mNumHist = lastInteresting;
mHaveGps = (aggrStates&HistoryItem.STATE_GPS_ON_FLAG) != 0;
mTextDescent = (int)mTextPaint.descent();
}
- void addPhoneSignalTick(int x, int bin) {
- mPhoneSignalTicks[mNumPhoneSignalTicks]
- = x | bin << PHONE_SIGNAL_BIN_SHIFT;
- mNumPhoneSignalTicks++;
- }
-
void finishPaths(int w, int h, int levelh, int startX, int y, Path curLevelPath,
int lastX, boolean lastCharging, boolean lastScreenOn, boolean lastGpsOn,
- boolean lastWifiRunning, boolean lastWakeLock, int lastPhoneSignal, Path lastPath) {
+ boolean lastWifiRunning, boolean lastWakeLock, Path lastPath) {
if (curLevelPath != null) {
if (lastX >= 0 && lastX < w) {
if (lastPath != null) {
if (lastWakeLock) {
mWakeLockPath.lineTo(w, h-mWakeLockOffset);
}
- if (lastPhoneSignal != 0) {
- addPhoneSignalTick(w, 0);
- }
+ mPhoneSignalChart.finish(w);
}
@Override
mLargeMode = true;
mLineWidth = textHeight/2;
mLevelTop = textHeight + mLineWidth;
+ mScreenOnPaint.setARGB(255, 32, 64, 255);
+ mGpsOnPaint.setARGB(255, 32, 64, 255);
+ mWifiRunningPaint.setARGB(255, 32, 64, 255);
+ mWakeLockPaint.setARGB(255, 32, 64, 255);
} else {
mLargeMode = false;
mLineWidth = mThinLineWidth;
mLevelTop = 0;
+ mScreenOnPaint.setARGB(255, 0, 0, 255);
+ mGpsOnPaint.setARGB(255, 0, 0, 255);
+ mWifiRunningPaint.setARGB(255, 0, 0, 255);
+ mWakeLockPaint.setARGB(255, 0, 0, 255);
}
if (mLineWidth <= 0) mLineWidth = 1;
mTextPaint.setStrokeWidth(mThinLineWidth);
mGpsOnOffset = mWifiRunningOffset + (mHaveWifi ? barOffset : 0);
mPhoneSignalOffset = mGpsOnOffset + (mHaveGps ? barOffset : 0);
mLevelOffset = mPhoneSignalOffset + barOffset + mLineWidth;
- mPhoneSignalTicks = new int[w+2];
+ mPhoneSignalChart.init(w);
} else {
mScreenOnOffset = mGpsOnOffset = mWifiRunningOffset
= mWakeLockOffset = mLineWidth;
mChargingOffset = mLineWidth*2;
mPhoneSignalOffset = 0;
mLevelOffset = mLineWidth*3;
- mPhoneSignalTicks = null;
+ mPhoneSignalChart.init(0);
}
mBatLevelPath.reset();
final int levelh = h - mLevelOffset - mLevelTop;
mLevelBottom = mLevelTop + levelh;
- BatteryStats.HistoryItem rec = mHistFirst;
int x = 0, y = 0, startX = 0, lastX = -1, lastY = -1;
int i = 0;
Path curLevelPath = null;
Path lastLinePath = null;
boolean lastCharging = false, lastScreenOn = false, lastGpsOn = false;
boolean lastWifiRunning = false, lastWakeLock = false;
- int lastPhoneSignalBin = 0;
final int N = mNumHist;
- while (rec != null && i < N) {
- if (rec.cmd == BatteryStats.HistoryItem.CMD_UPDATE) {
- x = (int)(((rec.time-timeStart)*w)/timeChange);
- y = mLevelTop + levelh - ((rec.batteryLevel-batLow)*(levelh-1))/batChange;
-
- if (lastX != x) {
- // We have moved by at least a pixel.
- if (lastY != y) {
- // Don't plot changes within a pixel.
- Path path;
- byte value = rec.batteryLevel;
- if (value <= BATTERY_CRITICAL) path = mBatCriticalPath;
- else if (value <= BATTERY_WARN) path = mBatWarnPath;
- else path = mBatGoodPath;
-
- if (path != lastLinePath) {
- if (lastLinePath != null) {
- lastLinePath.lineTo(x, y);
+ if (mStats.startIteratingHistoryLocked()) {
+ final HistoryItem rec = new HistoryItem();
+ while (mStats.getNextHistoryLocked(rec) && i < N) {
+ if (rec.cmd == BatteryStats.HistoryItem.CMD_UPDATE) {
+ x = (int)(((rec.time-timeStart)*w)/timeChange);
+ y = mLevelTop + levelh - ((rec.batteryLevel-batLow)*(levelh-1))/batChange;
+
+ if (lastX != x) {
+ // We have moved by at least a pixel.
+ if (lastY != y) {
+ // Don't plot changes within a pixel.
+ Path path;
+ byte value = rec.batteryLevel;
+ if (value <= BATTERY_CRITICAL) path = mBatCriticalPath;
+ else if (value <= BATTERY_WARN) path = mBatWarnPath;
+ else path = mBatGoodPath;
+
+ if (path != lastLinePath) {
+ if (lastLinePath != null) {
+ lastLinePath.lineTo(x, y);
+ }
+ path.moveTo(x, y);
+ lastLinePath = path;
+ } else {
+ path.lineTo(x, y);
+ }
+
+ if (curLevelPath == null) {
+ curLevelPath = mBatLevelPath;
+ curLevelPath.moveTo(x, y);
+ startX = x;
+ } else {
+ curLevelPath.lineTo(x, y);
}
- path.moveTo(x, y);
- lastLinePath = path;
- } else {
- path.lineTo(x, y);
+ lastX = x;
+ lastY = y;
}
-
- if (curLevelPath == null) {
- curLevelPath = mBatLevelPath;
- curLevelPath.moveTo(x, y);
- startX = x;
- } else {
- curLevelPath.lineTo(x, y);
+
+ final boolean charging =
+ (rec.states&HistoryItem.STATE_BATTERY_PLUGGED_FLAG) != 0;
+ if (charging != lastCharging) {
+ if (charging) {
+ mChargingPath.moveTo(x, h-mChargingOffset);
+ } else {
+ mChargingPath.lineTo(x, h-mChargingOffset);
+ }
+ lastCharging = charging;
}
- lastX = x;
- lastY = y;
- }
- final boolean charging =
- (rec.states&HistoryItem.STATE_BATTERY_PLUGGED_FLAG) != 0;
- if (charging != lastCharging) {
- if (charging) {
- mChargingPath.moveTo(x, h-mChargingOffset);
- } else {
- mChargingPath.lineTo(x, h-mChargingOffset);
+ final boolean screenOn =
+ (rec.states&HistoryItem.STATE_SCREEN_ON_FLAG) != 0;
+ if (screenOn != lastScreenOn) {
+ if (screenOn) {
+ mScreenOnPath.moveTo(x, h-mScreenOnOffset);
+ } else {
+ mScreenOnPath.lineTo(x, h-mScreenOnOffset);
+ }
+ lastScreenOn = screenOn;
}
- lastCharging = charging;
- }
- final boolean screenOn =
- (rec.states&HistoryItem.STATE_SCREEN_ON_FLAG) != 0;
- if (screenOn != lastScreenOn) {
- if (screenOn) {
- mScreenOnPath.moveTo(x, h-mScreenOnOffset);
- } else {
- mScreenOnPath.lineTo(x, h-mScreenOnOffset);
+ final boolean gpsOn =
+ (rec.states&HistoryItem.STATE_GPS_ON_FLAG) != 0;
+ if (gpsOn != lastGpsOn) {
+ if (gpsOn) {
+ mGpsOnPath.moveTo(x, h-mGpsOnOffset);
+ } else {
+ mGpsOnPath.lineTo(x, h-mGpsOnOffset);
+ }
+ lastGpsOn = gpsOn;
}
- lastScreenOn = screenOn;
- }
- final boolean gpsOn =
- (rec.states&HistoryItem.STATE_GPS_ON_FLAG) != 0;
- if (gpsOn != lastGpsOn) {
- if (gpsOn) {
- mGpsOnPath.moveTo(x, h-mGpsOnOffset);
- } else {
- mGpsOnPath.lineTo(x, h-mGpsOnOffset);
+ final boolean wifiRunning =
+ (rec.states&HistoryItem.STATE_WIFI_RUNNING_FLAG) != 0;
+ if (wifiRunning != lastWifiRunning) {
+ if (wifiRunning) {
+ mWifiRunningPath.moveTo(x, h-mWifiRunningOffset);
+ } else {
+ mWifiRunningPath.lineTo(x, h-mWifiRunningOffset);
+ }
+ lastWifiRunning = wifiRunning;
}
- lastGpsOn = gpsOn;
- }
- final boolean wifiRunning =
- (rec.states&HistoryItem.STATE_WIFI_RUNNING_FLAG) != 0;
- if (wifiRunning != lastWifiRunning) {
- if (wifiRunning) {
- mWifiRunningPath.moveTo(x, h-mWifiRunningOffset);
- } else {
- mWifiRunningPath.lineTo(x, h-mWifiRunningOffset);
+ final boolean wakeLock =
+ (rec.states&HistoryItem.STATE_WAKE_LOCK_FLAG) != 0;
+ if (wakeLock != lastWakeLock) {
+ if (wakeLock) {
+ mWakeLockPath.moveTo(x, h-mWakeLockOffset);
+ } else {
+ mWakeLockPath.lineTo(x, h-mWakeLockOffset);
+ }
+ lastWakeLock = wakeLock;
}
- lastWifiRunning = wifiRunning;
- }
- final boolean wakeLock =
- (rec.states&HistoryItem.STATE_WAKE_LOCK_FLAG) != 0;
- if (wakeLock != lastWakeLock) {
- if (wakeLock) {
- mWakeLockPath.moveTo(x, h-mWakeLockOffset);
- } else {
- mWakeLockPath.lineTo(x, h-mWakeLockOffset);
+ if (mLargeMode) {
+ int bin;
+ if (((rec.states&HistoryItem.STATE_PHONE_STATE_MASK)
+ >> HistoryItem.STATE_PHONE_STATE_SHIFT)
+ == ServiceState.STATE_POWER_OFF) {
+ bin = 0;
+ } else if ((rec.states&HistoryItem.STATE_PHONE_SCANNING_FLAG) != 0) {
+ bin = 1;
+ } else {
+ bin = (rec.states&HistoryItem.STATE_SIGNAL_STRENGTH_MASK)
+ >> HistoryItem.STATE_SIGNAL_STRENGTH_SHIFT;
+ bin += 2;
+ }
+ mPhoneSignalChart.addTick(x, bin);
}
- lastWakeLock = wakeLock;
}
- if (mLargeMode) {
- int bin;
- if (((rec.states&HistoryItem.STATE_PHONE_STATE_MASK)
- >> HistoryItem.STATE_PHONE_STATE_SHIFT)
- == ServiceState.STATE_POWER_OFF) {
- bin = 0;
- } else if ((rec.states&HistoryItem.STATE_PHONE_SCANNING_FLAG) != 0) {
- bin = 1;
- } else {
- bin = (rec.states&HistoryItem.STATE_SIGNAL_STRENGTH_MASK)
- >> HistoryItem.STATE_SIGNAL_STRENGTH_SHIFT;
- bin += 2;
- }
- if (bin != lastPhoneSignalBin) {
- addPhoneSignalTick(x, bin);
- lastPhoneSignalBin = bin;
- }
+ } else if (rec.cmd != BatteryStats.HistoryItem.CMD_OVERFLOW) {
+ if (curLevelPath != null) {
+ finishPaths(x+1, h, levelh, startX, lastY, curLevelPath, lastX,
+ lastCharging, lastScreenOn, lastGpsOn, lastWifiRunning,
+ lastWakeLock, lastLinePath);
+ lastX = lastY = -1;
+ curLevelPath = null;
+ lastLinePath = null;
+ lastCharging = lastScreenOn = lastGpsOn = lastWakeLock = false;
}
}
- } else if (rec.cmd != BatteryStats.HistoryItem.CMD_OVERFLOW) {
- if (curLevelPath != null) {
- finishPaths(x+1, h, levelh, startX, lastY, curLevelPath, lastX,
- lastCharging, lastScreenOn, lastGpsOn, lastWifiRunning,
- lastWakeLock, lastPhoneSignalBin, lastLinePath);
- lastX = lastY = -1;
- curLevelPath = null;
- lastLinePath = null;
- lastCharging = lastScreenOn = lastGpsOn = lastWakeLock = false;
- lastPhoneSignalBin = 0;
- }
+ i++;
}
-
- rec = rec.next;
- i++;
}
finishPaths(w, h, levelh, startX, lastY, curLevelPath, lastX,
lastCharging, lastScreenOn, lastGpsOn, lastWifiRunning,
- lastWakeLock, lastPhoneSignalBin, lastLinePath);
+ lastWakeLock, lastLinePath);
}
@Override
if (!mBatCriticalPath.isEmpty()) {
canvas.drawPath(mBatCriticalPath, mBatteryCriticalPaint);
}
- int lastBin=0, lastX=0;
int top = height-mPhoneSignalOffset - (mLineWidth/2);
- int bottom = top + mLineWidth;
- for (int i=0; i<mNumPhoneSignalTicks; i++) {
- int tick = mPhoneSignalTicks[i];
- int x = tick&PHONE_SIGNAL_X_MASK;
- int bin = (tick&PHONE_SIGNAL_BIN_MASK) >> PHONE_SIGNAL_BIN_SHIFT;
- if (lastBin != 0) {
- canvas.drawRect(lastX, top, x, bottom, mPhoneSignalPaints[lastBin]);
- }
- lastBin = bin;
- lastX = x;
- }
+ mPhoneSignalChart.draw(canvas, top, mLineWidth);
if (!mScreenOnPath.isEmpty()) {
canvas.drawPath(mScreenOnPath, mScreenOnPaint);
}
import android.content.Context;
import android.content.Intent;
-import android.graphics.drawable.Drawable;
import android.hardware.SensorManager;
import android.os.BatteryStats;
import android.os.Bundle;
BatteryStatsImpl mStats;
private final List<BatterySipper> mUsageList = new ArrayList<BatterySipper>();
private final List<BatterySipper> mWifiSippers = new ArrayList<BatterySipper>();
+ private final List<BatterySipper> mBluetoothSippers = new ArrayList<BatterySipper>();
private PreferenceGroup mAppListGroup;
private double mMaxPower = 1;
private double mTotalPower;
private double mWifiPower;
+ private double mBluetoothPower;
private PowerProfile mPowerProfile;
// How much the apps together have left WIFI running.
sipper.tcpBytesReceived,
};
} break;
+ case BLUETOOTH:
+ {
+ types = new int[] {
+ R.string.usage_type_on_time,
+ R.string.usage_type_cpu,
+ R.string.usage_type_cpu_foreground,
+ R.string.usage_type_wake_lock,
+ R.string.usage_type_data_send,
+ R.string.usage_type_data_recv,
+ };
+ values = new double[] {
+ sipper.usageTime,
+ sipper.cpuTime,
+ sipper.cpuFgTime,
+ sipper.wakeLockTime,
+ sipper.tcpBytesSent,
+ sipper.tcpBytesReceived,
+ };
+ } break;
default:
{
types = new int[] {
mMaxPower = 0;
mTotalPower = 0;
mWifiPower = 0;
+ mBluetoothPower = 0;
mAppWifiRunning = 0;
mAppListGroup.removeAll();
mUsageList.clear();
mWifiSippers.clear();
+ mBluetoothSippers.clear();
processAppUsage();
processMiscUsage();
}
cpuTime += tmpCpuTime;
power += processPower;
- if (highestDrain < processPower) {
+ if (packageWithHighestDrain == null
+ || packageWithHighestDrain.startsWith("*")) {
+ highestDrain = processPower;
+ packageWithHighestDrain = ent.getKey();
+ } else if (highestDrain < processPower
+ && !ent.getKey().startsWith("*")) {
highestDrain = processPower;
packageWithHighestDrain = ent.getKey();
}
-
}
if (DEBUG) Log.i(TAG, "Max drain of " + highestDrain
+ " by " + packageWithHighestDrain);
app.tcpBytesSent = tcpBytesSent;
if (u.getUid() == Process.WIFI_UID) {
mWifiSippers.add(app);
+ } else if (u.getUid() == Process.BLUETOOTH_GID) {
+ mBluetoothSippers.add(app);
} else {
mUsageList.add(app);
}
}
if (u.getUid() == Process.WIFI_UID) {
mWifiPower += power;
+ } else if (u.getUid() == Process.BLUETOOTH_GID) {
+ mBluetoothPower += power;
} else {
if (power > mMaxPower) mMaxPower = power;
mTotalPower += power;
}
}
+ private void aggregateSippers(BatterySipper bs, List<BatterySipper> from, String tag) {
+ for (int i=0; i<from.size(); i++) {
+ BatterySipper wbs = from.get(i);
+ if (DEBUG) Log.i(TAG, tag + " adding sipper " + wbs + ": cpu=" + wbs.cpuTime);
+ bs.cpuTime += wbs.cpuTime;
+ bs.gpsTime += wbs.gpsTime;
+ bs.wifiRunningTime += wbs.wifiRunningTime;
+ bs.cpuFgTime += wbs.cpuFgTime;
+ bs.wakeLockTime += wbs.wakeLockTime;
+ bs.tcpBytesReceived += wbs.tcpBytesReceived;
+ bs.tcpBytesSent += wbs.tcpBytesSent;
+ }
+ }
+
private void addWiFiUsage(long uSecNow) {
long onTimeMs = mStats.getWifiOnTime(uSecNow, mStatsType) / 1000;
long runningTimeMs = mStats.getGlobalWifiRunningTime(uSecNow, mStatsType) / 1000;
if (DEBUG) Log.i(TAG, "WIFI power=" + wifiPower + " from procs=" + mWifiPower);
BatterySipper bs = addEntry(getString(R.string.power_wifi), DrainType.WIFI, runningTimeMs,
R.drawable.ic_settings_wifi, wifiPower + mWifiPower);
- for (int i=0; i<mWifiSippers.size(); i++) {
- BatterySipper wbs = mWifiSippers.get(i);
- if (DEBUG) Log.i(TAG, "WIFI adding sipper " + wbs + ": cpu=" + wbs.cpuTime);
- bs.cpuTime += wbs.cpuTime;
- bs.gpsTime += wbs.gpsTime;
- bs.wifiRunningTime += wbs.wifiRunningTime;
- bs.cpuFgTime += wbs.cpuFgTime;
- bs.wakeLockTime += wbs.wakeLockTime;
- bs.tcpBytesReceived += wbs.tcpBytesReceived;
- bs.tcpBytesSent += wbs.tcpBytesSent;
- }
+ aggregateSippers(bs, mWifiSippers, "WIFI");
}
private void addIdleUsage(long uSecNow) {
int btPingCount = mStats.getBluetoothPingCount();
btPower += (btPingCount
* mPowerProfile.getAveragePower(PowerProfile.POWER_BLUETOOTH_AT_CMD)) / 1000;
-
- addEntry(getString(R.string.power_bluetooth), DrainType.BLUETOOTH, btOnTimeMs,
- R.drawable.ic_settings_bluetooth, btPower);
+ BatterySipper bs = addEntry(getString(R.string.power_bluetooth), DrainType.BLUETOOTH,
+ btOnTimeMs, R.drawable.ic_settings_bluetooth, btPower + mBluetoothPower);
+ aggregateSippers(bs, mBluetoothSippers, "Bluetooth");
}
private double getAverageDataCost() {
OSDN Git Service
