blob: 0a6e2ab12b018b69df8f1e1a8470fbe027a0067d [file] [log] [blame]
/*
* Copyright (C) 2009 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.settings.fuelgauge;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.pm.UserInfo;
import android.graphics.drawable.Drawable;
import android.hardware.SensorManager;
import android.net.Uri;
import android.os.BatteryStats;
import android.os.BatteryStats.Uid;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.os.Parcel;
import android.os.Process;
import android.os.RemoteException;
import android.os.ServiceManager;
import android.os.SystemClock;
import android.os.UserHandle;
import android.os.UserManager;
import android.preference.Preference;
import android.preference.PreferenceActivity;
import android.preference.PreferenceFragment;
import android.preference.PreferenceGroup;
import android.preference.PreferenceScreen;
import android.telephony.SignalStrength;
import android.text.TextUtils;
import android.util.Log;
import android.util.SparseArray;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import com.android.internal.app.IBatteryStats;
import com.android.internal.os.BatteryStatsImpl;
import com.android.internal.os.PowerProfile;
import com.android.settings.HelpUtils;
import com.android.settings.R;
import com.android.settings.fuelgauge.PowerUsageDetail.DrainType;
import com.android.settings.users.UserUtils;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.io.Writer;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
/**
* Displays a list of apps and subsystems that consume power, ordered by how much power was
* consumed since the last time it was unplugged.
*/
public class PowerUsageSummary extends PreferenceFragment implements Runnable {
private static final boolean DEBUG = false;
private static final String TAG = "PowerUsageSummary";
private static final String KEY_APP_LIST = "app_list";
private static final String KEY_BATTERY_STATUS = "battery_status";
private static final int MENU_STATS_TYPE = Menu.FIRST;
private static final int MENU_STATS_REFRESH = Menu.FIRST + 1;
private static final int MENU_HELP = Menu.FIRST + 2;
private static BatteryStatsImpl sStatsXfer;
IBatteryStats mBatteryInfo;
UserManager mUm;
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 final SparseArray<List<BatterySipper>> mUserSippers
= new SparseArray<List<BatterySipper>>();
private final SparseArray<Double> mUserPower = new SparseArray<Double>();
private PreferenceGroup mAppListGroup;
private Preference mBatteryStatusPref;
private int mStatsType = BatteryStats.STATS_SINCE_CHARGED;
private static final int MIN_POWER_THRESHOLD = 5;
private static final int MAX_ITEMS_TO_LIST = 10;
private long mStatsPeriod = 0;
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.
private long mAppWifiRunning;
/** Queue for fetching name and icon for an application */
private ArrayList<BatterySipper> mRequestQueue = new ArrayList<BatterySipper>();
private Thread mRequestThread;
private boolean mAbort;
private BroadcastReceiver mBatteryInfoReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();
if (Intent.ACTION_BATTERY_CHANGED.equals(action)) {
String batteryLevel = com.android.settings.Utils.getBatteryPercentage(intent);
String batteryStatus = com.android.settings.Utils.getBatteryStatus(getResources(),
intent);
String batterySummary = context.getResources().getString(
R.string.power_usage_level_and_status, batteryLevel, batteryStatus);
mBatteryStatusPref.setTitle(batterySummary);
}
}
};
@Override
public void onCreate(Bundle icicle) {
super.onCreate(icicle);
if (icicle != null) {
mStats = sStatsXfer;
}
addPreferencesFromResource(R.xml.power_usage_summary);
mBatteryInfo = IBatteryStats.Stub.asInterface(
ServiceManager.getService("batteryinfo"));
mUm = (UserManager)getActivity().getSystemService(Context.USER_SERVICE);
mAppListGroup = (PreferenceGroup) findPreference(KEY_APP_LIST);
mBatteryStatusPref = mAppListGroup.findPreference(KEY_BATTERY_STATUS);
mPowerProfile = new PowerProfile(getActivity());
setHasOptionsMenu(true);
}
@Override
public void onResume() {
super.onResume();
mAbort = false;
getActivity().registerReceiver(mBatteryInfoReceiver,
new IntentFilter(Intent.ACTION_BATTERY_CHANGED));
refreshStats();
}
@Override
public void onPause() {
synchronized (mRequestQueue) {
mAbort = true;
}
mHandler.removeMessages(MSG_UPDATE_NAME_ICON);
getActivity().unregisterReceiver(mBatteryInfoReceiver);
super.onPause();
}
@Override
public void onDestroy() {
super.onDestroy();
if (getActivity().isChangingConfigurations()) {
sStatsXfer = mStats;
}
}
@Override
public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference) {
if (preference instanceof BatteryHistoryPreference) {
Parcel hist = Parcel.obtain();
mStats.writeToParcelWithoutUids(hist, 0);
byte[] histData = hist.marshall();
Bundle args = new Bundle();
args.putByteArray(BatteryHistoryDetail.EXTRA_STATS, histData);
PreferenceActivity pa = (PreferenceActivity)getActivity();
pa.startPreferencePanel(BatteryHistoryDetail.class.getName(), args,
R.string.history_details_title, null, null, 0);
return super.onPreferenceTreeClick(preferenceScreen, preference);
}
if (!(preference instanceof PowerGaugePreference)) {
return false;
}
PowerGaugePreference pgp = (PowerGaugePreference) preference;
BatterySipper sipper = pgp.getInfo();
Bundle args = new Bundle();
args.putString(PowerUsageDetail.EXTRA_TITLE, sipper.name);
args.putInt(PowerUsageDetail.EXTRA_PERCENT, (int)
Math.ceil(sipper.getSortValue() * 100 / mTotalPower));
args.putInt(PowerUsageDetail.EXTRA_GAUGE, (int)
Math.ceil(sipper.getSortValue() * 100 / mMaxPower));
args.putLong(PowerUsageDetail.EXTRA_USAGE_DURATION, mStatsPeriod);
args.putString(PowerUsageDetail.EXTRA_ICON_PACKAGE, sipper.defaultPackageName);
args.putInt(PowerUsageDetail.EXTRA_ICON_ID, sipper.iconId);
args.putDouble(PowerUsageDetail.EXTRA_NO_COVERAGE, sipper.noCoveragePercent);
if (sipper.uidObj != null) {
args.putInt(PowerUsageDetail.EXTRA_UID, sipper.uidObj.getUid());
}
args.putSerializable(PowerUsageDetail.EXTRA_DRAIN_TYPE, sipper.drainType);
int[] types;
double[] values;
switch (sipper.drainType) {
case APP:
case USER:
{
Uid uid = sipper.uidObj;
types = new int[] {
R.string.usage_type_cpu,
R.string.usage_type_cpu_foreground,
R.string.usage_type_wake_lock,
R.string.usage_type_gps,
R.string.usage_type_wifi_running,
R.string.usage_type_data_send,
R.string.usage_type_data_recv,
R.string.usage_type_audio,
R.string.usage_type_video,
};
values = new double[] {
sipper.cpuTime,
sipper.cpuFgTime,
sipper.wakeLockTime,
sipper.gpsTime,
sipper.wifiRunningTime,
sipper.tcpBytesSent,
sipper.tcpBytesReceived,
0,
0
};
if (sipper.drainType == DrainType.APP) {
Writer result = new StringWriter();
PrintWriter printWriter = new PrintWriter(result);
mStats.dumpLocked(printWriter, "", mStatsType, uid.getUid());
args.putString(PowerUsageDetail.EXTRA_REPORT_DETAILS, result.toString());
result = new StringWriter();
printWriter = new PrintWriter(result);
mStats.dumpCheckinLocked(printWriter, mStatsType, uid.getUid());
args.putString(PowerUsageDetail.EXTRA_REPORT_CHECKIN_DETAILS,
result.toString());
}
}
break;
case CELL:
{
types = new int[] {
R.string.usage_type_on_time,
R.string.usage_type_no_coverage
};
values = new double[] {
sipper.usageTime,
sipper.noCoveragePercent
};
}
break;
case WIFI:
{
types = new int[] {
R.string.usage_type_wifi_running,
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;
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[] {
R.string.usage_type_on_time
};
values = new double[] {
sipper.usageTime
};
}
}
args.putIntArray(PowerUsageDetail.EXTRA_DETAIL_TYPES, types);
args.putDoubleArray(PowerUsageDetail.EXTRA_DETAIL_VALUES, values);
PreferenceActivity pa = (PreferenceActivity)getActivity();
pa.startPreferencePanel(PowerUsageDetail.class.getName(), args,
R.string.details_title, null, null, 0);
return super.onPreferenceTreeClick(preferenceScreen, preference);
}
@Override
public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
if (DEBUG) {
menu.add(0, MENU_STATS_TYPE, 0, R.string.menu_stats_total)
.setIcon(com.android.internal.R.drawable.ic_menu_info_details)
.setAlphabeticShortcut('t');
}
MenuItem refresh = menu.add(0, MENU_STATS_REFRESH, 0, R.string.menu_stats_refresh)
.setIcon(R.drawable.ic_menu_refresh_holo_dark)
.setAlphabeticShortcut('r');
refresh.setShowAsAction(MenuItem.SHOW_AS_ACTION_IF_ROOM |
MenuItem.SHOW_AS_ACTION_WITH_TEXT);
String helpUrl;
if (!TextUtils.isEmpty(helpUrl = getResources().getString(R.string.help_url_battery))) {
final MenuItem help = menu.add(0, MENU_HELP, 0, R.string.help_label);
HelpUtils.prepareHelpMenuItem(getActivity(), help, helpUrl);
}
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
case MENU_STATS_TYPE:
if (mStatsType == BatteryStats.STATS_SINCE_CHARGED) {
mStatsType = BatteryStats.STATS_SINCE_UNPLUGGED;
} else {
mStatsType = BatteryStats.STATS_SINCE_CHARGED;
}
refreshStats();
return true;
case MENU_STATS_REFRESH:
mStats = null;
refreshStats();
return true;
default:
return false;
}
}
private void addNotAvailableMessage() {
Preference notAvailable = new Preference(getActivity());
notAvailable.setTitle(R.string.power_usage_not_available);
mAppListGroup.addPreference(notAvailable);
}
private void refreshStats() {
if (mStats == null) {
load();
}
mMaxPower = 0;
mTotalPower = 0;
mWifiPower = 0;
mBluetoothPower = 0;
mAppWifiRunning = 0;
mAppListGroup.removeAll();
mUsageList.clear();
mWifiSippers.clear();
mBluetoothSippers.clear();
mUserSippers.clear();
mUserPower.clear();
mAppListGroup.setOrderingAsAdded(false);
mBatteryStatusPref.setOrder(-2);
mAppListGroup.addPreference(mBatteryStatusPref);
BatteryHistoryPreference hist = new BatteryHistoryPreference(getActivity(), mStats);
hist.setOrder(-1);
mAppListGroup.addPreference(hist);
if (mPowerProfile.getAveragePower(PowerProfile.POWER_SCREEN_FULL) < 10) {
addNotAvailableMessage();
return;
}
processAppUsage();
processMiscUsage();
Collections.sort(mUsageList);
for (BatterySipper sipper : mUsageList) {
if (sipper.getSortValue() < MIN_POWER_THRESHOLD) continue;
final double percentOfTotal = ((sipper.getSortValue() / mTotalPower) * 100);
if (percentOfTotal < 1) continue;
PowerGaugePreference pref = new PowerGaugePreference(getActivity(), sipper.getIcon(), sipper);
final double percentOfMax = (sipper.getSortValue() * 100) / mMaxPower;
sipper.percent = percentOfTotal;
pref.setTitle(sipper.name);
pref.setOrder(Integer.MAX_VALUE - (int) sipper.getSortValue()); // Invert the order
pref.setPercent(percentOfMax, percentOfTotal);
if (sipper.uidObj != null) {
pref.setKey(Integer.toString(sipper.uidObj.getUid()));
}
mAppListGroup.addPreference(pref);
if (mAppListGroup.getPreferenceCount() > (MAX_ITEMS_TO_LIST+1)) break;
}
synchronized (mRequestQueue) {
if (!mRequestQueue.isEmpty()) {
if (mRequestThread == null) {
mRequestThread = new Thread(this, "BatteryUsage Icon Loader");
mRequestThread.setPriority(Thread.MIN_PRIORITY);
mRequestThread.start();
}
mRequestQueue.notify();
}
}
}
private void processAppUsage() {
SensorManager sensorManager = (SensorManager)getActivity().getSystemService(
Context.SENSOR_SERVICE);
final int which = mStatsType;
final int speedSteps = mPowerProfile.getNumSpeedSteps();
final double[] powerCpuNormal = new double[speedSteps];
final long[] cpuSpeedStepTimes = new long[speedSteps];
for (int p = 0; p < speedSteps; p++) {
powerCpuNormal[p] = mPowerProfile.getAveragePower(PowerProfile.POWER_CPU_ACTIVE, p);
}
final double averageCostPerByte = getAverageDataCost();
long uSecTime = mStats.computeBatteryRealtime(SystemClock.elapsedRealtime() * 1000, which);
long appWakelockTime = 0;
BatterySipper osApp = null;
mStatsPeriod = uSecTime;
SparseArray<? extends Uid> uidStats = mStats.getUidStats();
final int NU = uidStats.size();
for (int iu = 0; iu < NU; iu++) {
Uid u = uidStats.valueAt(iu);
double p;
double power = 0;
double highestDrain = 0;
String packageWithHighestDrain = null;
//mUsageList.add(new AppUsage(u.getUid(), new double[] {power}));
Map<String, ? extends BatteryStats.Uid.Proc> processStats = u.getProcessStats();
long cpuTime = 0;
long cpuFgTime = 0;
long wakelockTime = 0;
long gpsTime = 0;
if (DEBUG) Log.i(TAG, "UID " + u.getUid());
if (processStats.size() > 0) {
// Process CPU time
for (Map.Entry<String, ? extends BatteryStats.Uid.Proc> ent
: processStats.entrySet()) {
Uid.Proc ps = ent.getValue();
final long userTime = ps.getUserTime(which);
final long systemTime = ps.getSystemTime(which);
final long foregroundTime = ps.getForegroundTime(which);
cpuFgTime += foregroundTime * 10; // convert to millis
final long tmpCpuTime = (userTime + systemTime) * 10; // convert to millis
int totalTimeAtSpeeds = 0;
// Get the total first
for (int step = 0; step < speedSteps; step++) {
cpuSpeedStepTimes[step] = ps.getTimeAtCpuSpeedStep(step, which);
totalTimeAtSpeeds += cpuSpeedStepTimes[step];
}
if (totalTimeAtSpeeds == 0) totalTimeAtSpeeds = 1;
// Then compute the ratio of time spent at each speed
double processPower = 0;
for (int step = 0; step < speedSteps; step++) {
double ratio = (double) cpuSpeedStepTimes[step] / totalTimeAtSpeeds;
processPower += ratio * tmpCpuTime * powerCpuNormal[step];
}
cpuTime += tmpCpuTime;
if (DEBUG && processPower != 0) {
Log.i(TAG, String.format("process %s, cpu power=%.2f",
ent.getKey(), processPower / 1000));
}
power += processPower;
if (packageWithHighestDrain == null
|| packageWithHighestDrain.startsWith("*")) {
highestDrain = processPower;
packageWithHighestDrain = ent.getKey();
} else if (highestDrain < processPower
&& !ent.getKey().startsWith("*")) {
highestDrain = processPower;
packageWithHighestDrain = ent.getKey();
}
}
}
if (cpuFgTime > cpuTime) {
if (DEBUG && cpuFgTime > cpuTime + 10000) {
Log.i(TAG, "WARNING! Cputime is more than 10 seconds behind Foreground time");
}
cpuTime = cpuFgTime; // Statistics may not have been gathered yet.
}
power /= 1000;
if (DEBUG && power != 0) Log.i(TAG, String.format("total cpu power=%.2f", power));
// Process wake lock usage
Map<String, ? extends BatteryStats.Uid.Wakelock> wakelockStats = u.getWakelockStats();
for (Map.Entry<String, ? extends BatteryStats.Uid.Wakelock> wakelockEntry
: wakelockStats.entrySet()) {
Uid.Wakelock wakelock = wakelockEntry.getValue();
// Only care about partial wake locks since full wake locks
// are canceled when the user turns the screen off.
BatteryStats.Timer timer = wakelock.getWakeTime(BatteryStats.WAKE_TYPE_PARTIAL);
if (timer != null) {
wakelockTime += timer.getTotalTimeLocked(uSecTime, which);
}
}
wakelockTime /= 1000; // convert to millis
appWakelockTime += wakelockTime;
// Add cost of holding a wake lock
p = (wakelockTime
* mPowerProfile.getAveragePower(PowerProfile.POWER_CPU_AWAKE)) / 1000;
power += p;
if (DEBUG && p != 0) Log.i(TAG, String.format("wakelock power=%.2f", p));
// Add cost of data traffic
long tcpBytesReceived = u.getTcpBytesReceived(mStatsType);
long tcpBytesSent = u.getTcpBytesSent(mStatsType);
p = (tcpBytesReceived+tcpBytesSent) * averageCostPerByte;
power += p;
if (DEBUG && p != 0) Log.i(TAG, String.format("tcp power=%.2f", p));
// Add cost of keeping WIFI running.
long wifiRunningTimeMs = u.getWifiRunningTime(uSecTime, which) / 1000;
mAppWifiRunning += wifiRunningTimeMs;
p = (wifiRunningTimeMs
* mPowerProfile.getAveragePower(PowerProfile.POWER_WIFI_ON)) / 1000;
power += p;
if (DEBUG && p != 0) Log.i(TAG, String.format("wifi running power=%.2f", p));
// Add cost of WIFI scans
long wifiScanTimeMs = u.getWifiScanTime(uSecTime, which) / 1000;
p = (wifiScanTimeMs
* mPowerProfile.getAveragePower(PowerProfile.POWER_WIFI_SCAN)) / 1000;
power += p;
if (DEBUG && p != 0) Log.i(TAG, String.format("wifi scanning power=%.2f", p));
// Process Sensor usage
Map<Integer, ? extends BatteryStats.Uid.Sensor> sensorStats = u.getSensorStats();
for (Map.Entry<Integer, ? extends BatteryStats.Uid.Sensor> sensorEntry
: sensorStats.entrySet()) {
Uid.Sensor sensor = sensorEntry.getValue();
int sensorType = sensor.getHandle();
BatteryStats.Timer timer = sensor.getSensorTime();
long sensorTime = timer.getTotalTimeLocked(uSecTime, which) / 1000;
double multiplier = 0;
switch (sensorType) {
case Uid.Sensor.GPS:
multiplier = mPowerProfile.getAveragePower(PowerProfile.POWER_GPS_ON);
gpsTime = sensorTime;
break;
default:
android.hardware.Sensor sensorData =
sensorManager.getDefaultSensor(sensorType);
if (sensorData != null) {
multiplier = sensorData.getPower();
}
}
p = (multiplier * sensorTime) / 1000;
power += p;
if (DEBUG && p != 0) {
Log.i(TAG, String.format("sensor %s power=%.2f", sensor.toString(), p));
}
}
if (DEBUG) Log.i(TAG, String.format("UID %d total power=%.2f", u.getUid(), power));
// Add the app to the list if it is consuming power
boolean isOtherUser = false;
final int userId = UserHandle.getUserId(u.getUid());
if (power != 0 || u.getUid() == 0) {
BatterySipper app = new BatterySipper(getActivity(), mRequestQueue, mHandler,
packageWithHighestDrain, DrainType.APP, 0, u,
new double[] {power});
app.cpuTime = cpuTime;
app.gpsTime = gpsTime;
app.wifiRunningTime = wifiRunningTimeMs;
app.cpuFgTime = cpuFgTime;
app.wakeLockTime = wakelockTime;
app.tcpBytesReceived = tcpBytesReceived;
app.tcpBytesSent = tcpBytesSent;
if (u.getUid() == Process.WIFI_UID) {
mWifiSippers.add(app);
} else if (u.getUid() == Process.BLUETOOTH_GID) {
mBluetoothSippers.add(app);
} else if (userId != UserHandle.myUserId()
&& UserHandle.getAppId(u.getUid()) >= Process.FIRST_APPLICATION_UID) {
isOtherUser = true;
List<BatterySipper> list = mUserSippers.get(userId);
if (list == null) {
list = new ArrayList<BatterySipper>();
mUserSippers.put(userId, list);
}
list.add(app);
} else {
mUsageList.add(app);
}
if (u.getUid() == 0) {
osApp = app;
}
}
if (power != 0) {
if (u.getUid() == Process.WIFI_UID) {
mWifiPower += power;
} else if (u.getUid() == Process.BLUETOOTH_GID) {
mBluetoothPower += power;
} else if (isOtherUser) {
Double userPower = mUserPower.get(userId);
if (userPower == null) {
userPower = power;
} else {
userPower += power;
}
mUserPower.put(userId, userPower);
} else {
if (power > mMaxPower) mMaxPower = power;
mTotalPower += power;
}
}
}
// The device has probably been awake for longer than the screen on
// time and application wake lock time would account for. Assign
// this remainder to the OS, if possible.
if (osApp != null) {
long wakeTimeMillis = mStats.computeBatteryUptime(
SystemClock.uptimeMillis() * 1000, which) / 1000;
wakeTimeMillis -= appWakelockTime + (mStats.getScreenOnTime(
SystemClock.elapsedRealtime(), which) / 1000);
if (wakeTimeMillis > 0) {
double power = (wakeTimeMillis
* mPowerProfile.getAveragePower(PowerProfile.POWER_CPU_AWAKE)) / 1000;
if (DEBUG) Log.i(TAG, "OS wakeLockTime " + wakeTimeMillis + " power " + power);
osApp.wakeLockTime += wakeTimeMillis;
osApp.value += power;
osApp.values[0] += power;
if (osApp.value > mMaxPower) mMaxPower = osApp.value;
mTotalPower += power;
}
}
}
private void addPhoneUsage(long uSecNow) {
long phoneOnTimeMs = mStats.getPhoneOnTime(uSecNow, mStatsType) / 1000;
double phoneOnPower = mPowerProfile.getAveragePower(PowerProfile.POWER_RADIO_ACTIVE)
* phoneOnTimeMs / 1000;
addEntry(getActivity().getString(R.string.power_phone), DrainType.PHONE, phoneOnTimeMs,
R.drawable.ic_settings_voice_calls, phoneOnPower);
}
private void addScreenUsage(long uSecNow) {
double power = 0;
long screenOnTimeMs = mStats.getScreenOnTime(uSecNow, mStatsType) / 1000;
power += screenOnTimeMs * mPowerProfile.getAveragePower(PowerProfile.POWER_SCREEN_ON);
final double screenFullPower =
mPowerProfile.getAveragePower(PowerProfile.POWER_SCREEN_FULL);
for (int i = 0; i < BatteryStats.NUM_SCREEN_BRIGHTNESS_BINS; i++) {
double screenBinPower = screenFullPower * (i + 0.5f)
/ BatteryStats.NUM_SCREEN_BRIGHTNESS_BINS;
long brightnessTime = mStats.getScreenBrightnessTime(i, uSecNow, mStatsType) / 1000;
power += screenBinPower * brightnessTime;
if (DEBUG) {
Log.i(TAG, "Screen bin power = " + (int) screenBinPower + ", time = "
+ brightnessTime);
}
}
power /= 1000; // To seconds
addEntry(getActivity().getString(R.string.power_screen), DrainType.SCREEN, screenOnTimeMs,
R.drawable.ic_settings_display, power);
}
private void addRadioUsage(long uSecNow) {
double power = 0;
final int BINS = SignalStrength.NUM_SIGNAL_STRENGTH_BINS;
long signalTimeMs = 0;
for (int i = 0; i < BINS; i++) {
long strengthTimeMs = mStats.getPhoneSignalStrengthTime(i, uSecNow, mStatsType) / 1000;
power += strengthTimeMs / 1000
* mPowerProfile.getAveragePower(PowerProfile.POWER_RADIO_ON, i);
signalTimeMs += strengthTimeMs;
}
long scanningTimeMs = mStats.getPhoneSignalScanningTime(uSecNow, mStatsType) / 1000;
power += scanningTimeMs / 1000 * mPowerProfile.getAveragePower(
PowerProfile.POWER_RADIO_SCANNING);
BatterySipper bs =
addEntry(getActivity().getString(R.string.power_cell), DrainType.CELL,
signalTimeMs, R.drawable.ic_settings_cell_standby, power);
if (signalTimeMs != 0) {
bs.noCoveragePercent = mStats.getPhoneSignalStrengthTime(0, uSecNow, mStatsType)
/ 1000 * 100.0 / signalTimeMs;
}
}
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 runningTime=" + runningTimeMs
+ " app runningTime=" + mAppWifiRunning);
runningTimeMs -= mAppWifiRunning;
if (runningTimeMs < 0) runningTimeMs = 0;
double wifiPower = (onTimeMs * 0 /* TODO */
* mPowerProfile.getAveragePower(PowerProfile.POWER_WIFI_ON)
+ runningTimeMs * mPowerProfile.getAveragePower(PowerProfile.POWER_WIFI_ON)) / 1000;
if (DEBUG) Log.i(TAG, "WIFI power=" + wifiPower + " from procs=" + mWifiPower);
BatterySipper bs = addEntry(getActivity().getString(R.string.power_wifi), DrainType.WIFI,
runningTimeMs, R.drawable.ic_settings_wifi, wifiPower + mWifiPower);
aggregateSippers(bs, mWifiSippers, "WIFI");
}
private void addIdleUsage(long uSecNow) {
long idleTimeMs = (uSecNow - mStats.getScreenOnTime(uSecNow, mStatsType)) / 1000;
double idlePower = (idleTimeMs * mPowerProfile.getAveragePower(PowerProfile.POWER_CPU_IDLE))
/ 1000;
addEntry(getActivity().getString(R.string.power_idle), DrainType.IDLE, idleTimeMs,
R.drawable.ic_settings_phone_idle, idlePower);
}
private void addBluetoothUsage(long uSecNow) {
long btOnTimeMs = mStats.getBluetoothOnTime(uSecNow, mStatsType) / 1000;
double btPower = btOnTimeMs * mPowerProfile.getAveragePower(PowerProfile.POWER_BLUETOOTH_ON)
/ 1000;
int btPingCount = mStats.getBluetoothPingCount();
btPower += (btPingCount
* mPowerProfile.getAveragePower(PowerProfile.POWER_BLUETOOTH_AT_CMD)) / 1000;
BatterySipper bs = addEntry(getActivity().getString(R.string.power_bluetooth),
DrainType.BLUETOOTH, btOnTimeMs, R.drawable.ic_settings_bluetooth,
btPower + mBluetoothPower);
aggregateSippers(bs, mBluetoothSippers, "Bluetooth");
}
private void addUserUsage() {
for (int i=0; i<mUserSippers.size(); i++) {
final int userId = mUserSippers.keyAt(i);
final List<BatterySipper> sippers = mUserSippers.valueAt(i);
UserInfo info = mUm.getUserInfo(userId);
Drawable icon;
String name;
if (info != null) {
icon = UserUtils.getUserIcon(mUm, info, getResources());
name = info != null ? info.name : null;
if (name == null) {
name = Integer.toString(info.id);
}
name = getActivity().getResources().getString(
R.string.running_process_item_user_label, name);
} else {
icon = null;
name = getActivity().getResources().getString(
R.string.running_process_item_removed_user_label);
}
double power = mUserPower.get(userId);
BatterySipper bs = addEntry(name, DrainType.USER, 0, 0, power);
bs.icon = icon;
aggregateSippers(bs, sippers, "User");
}
}
private double getAverageDataCost() {
final long WIFI_BPS = 1000000; // TODO: Extract average bit rates from system
final long MOBILE_BPS = 200000; // TODO: Extract average bit rates from system
final double WIFI_POWER = mPowerProfile.getAveragePower(PowerProfile.POWER_WIFI_ACTIVE)
/ 3600;
final double MOBILE_POWER = mPowerProfile.getAveragePower(PowerProfile.POWER_RADIO_ACTIVE)
/ 3600;
final long mobileData = mStats.getMobileTcpBytesReceived(mStatsType) +
mStats.getMobileTcpBytesSent(mStatsType);
final long wifiData = mStats.getTotalTcpBytesReceived(mStatsType) +
mStats.getTotalTcpBytesSent(mStatsType) - mobileData;
final long radioDataUptimeMs = mStats.getRadioDataUptime() / 1000;
final long mobileBps = radioDataUptimeMs != 0
? mobileData * 8 * 1000 / radioDataUptimeMs
: MOBILE_BPS;
double mobileCostPerByte = MOBILE_POWER / (mobileBps / 8);
double wifiCostPerByte = WIFI_POWER / (WIFI_BPS / 8);
if (wifiData + mobileData != 0) {
return (mobileCostPerByte * mobileData + wifiCostPerByte * wifiData)
/ (mobileData + wifiData);
} else {
return 0;
}
}
private void processMiscUsage() {
final int which = mStatsType;
long uSecTime = SystemClock.elapsedRealtime() * 1000;
final long uSecNow = mStats.computeBatteryRealtime(uSecTime, which);
final long timeSinceUnplugged = uSecNow;
if (DEBUG) {
Log.i(TAG, "Uptime since last unplugged = " + (timeSinceUnplugged / 1000));
}
addUserUsage();
addPhoneUsage(uSecNow);
addScreenUsage(uSecNow);
addWiFiUsage(uSecNow);
addBluetoothUsage(uSecNow);
addIdleUsage(uSecNow); // Not including cellular idle power
// Don't compute radio usage if it's a wifi-only device
if (!com.android.settings.Utils.isWifiOnly(getActivity())) {
addRadioUsage(uSecNow);
}
}
private BatterySipper addEntry(String label, DrainType drainType, long time, int iconId,
double power) {
if (power > mMaxPower) mMaxPower = power;
mTotalPower += power;
BatterySipper bs = new BatterySipper(getActivity(), mRequestQueue, mHandler,
label, drainType, iconId, null, new double[] {power});
bs.usageTime = time;
bs.iconId = iconId;
mUsageList.add(bs);
return bs;
}
private void load() {
try {
byte[] data = mBatteryInfo.getStatistics();
Parcel parcel = Parcel.obtain();
parcel.unmarshall(data, 0, data.length);
parcel.setDataPosition(0);
mStats = com.android.internal.os.BatteryStatsImpl.CREATOR
.createFromParcel(parcel);
mStats.distributeWorkLocked(BatteryStats.STATS_SINCE_CHARGED);
} catch (RemoteException e) {
Log.e(TAG, "RemoteException:", e);
}
}
public void run() {
while (true) {
BatterySipper bs;
synchronized (mRequestQueue) {
if (mRequestQueue.isEmpty() || mAbort) {
mRequestThread = null;
return;
}
bs = mRequestQueue.remove(0);
}
bs.getNameIcon();
}
}
static final int MSG_UPDATE_NAME_ICON = 1;
Handler mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case MSG_UPDATE_NAME_ICON:
BatterySipper bs = (BatterySipper) msg.obj;
PowerGaugePreference pgp =
(PowerGaugePreference) findPreference(
Integer.toString(bs.uidObj.getUid()));
if (pgp != null) {
pgp.setIcon(bs.icon);
pgp.setTitle(bs.name);
}
break;
}
super.handleMessage(msg);
}
};
}