2 * Copyright (C) 2006 The Android Open Source Project
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
17 package com.android.server;
19 import com.android.internal.app.IBatteryStats;
20 import com.android.server.am.BatteryStatsService;
22 import android.app.ActivityManagerNative;
23 import android.content.ContentResolver;
24 import android.content.Context;
25 import android.content.Intent;
26 import android.content.pm.PackageManager;
27 import android.os.BatteryManager;
28 import android.os.Binder;
29 import android.os.IBinder;
30 import android.os.DropBoxManager;
31 import android.os.RemoteException;
32 import android.os.ServiceManager;
33 import android.os.SystemClock;
34 import android.os.UEventObserver;
35 import android.provider.Settings;
36 import android.util.EventLog;
37 import android.util.Slog;
40 import java.io.FileDescriptor;
41 import java.io.FileInputStream;
42 import java.io.FileOutputStream;
43 import java.io.IOException;
44 import java.io.PrintWriter;
48 * <p>BatteryService monitors the charging status, and charge level of the device
49 * battery. When these values change this service broadcasts the new values
50 * to all {@link android.content.BroadcastReceiver IntentReceivers} that are
51 * watching the {@link android.content.Intent#ACTION_BATTERY_CHANGED
52 * BATTERY_CHANGED} action.</p>
53 * <p>The new values are stored in the Intent data and can be retrieved by
54 * calling {@link android.content.Intent#getExtra Intent.getExtra} with the
56 * <p>"scale" - int, the maximum value for the charge level</p>
57 * <p>"level" - int, charge level, from 0 through "scale" inclusive</p>
58 * <p>"status" - String, the current charging status.<br />
59 * <p>"health" - String, the current battery health.<br />
60 * <p>"present" - boolean, true if the battery is present<br />
61 * <p>"icon-small" - int, suggested small icon to use for this state</p>
62 * <p>"plugged" - int, 0 if the device is not plugged in; 1 if plugged
63 * into an AC power adapter; 2 if plugged in via USB.</p>
64 * <p>"voltage" - int, current battery voltage in millivolts</p>
65 * <p>"temperature" - int, current battery temperature in tenths of
66 * a degree Centigrade</p>
67 * <p>"technology" - String, the type of battery installed, e.g. "Li-ion"</p>
69 class BatteryService extends Binder {
70 private static final String TAG = BatteryService.class.getSimpleName();
72 private static final boolean LOCAL_LOGV = false;
74 static final int BATTERY_SCALE = 100; // battery capacity is a percentage
76 // Used locally for determining when to make a last ditch effort to log
77 // discharge stats before the device dies.
78 private static final int CRITICAL_BATTERY_LEVEL = 4;
80 private static final int DUMP_MAX_LENGTH = 24 * 1024;
81 private static final String[] DUMPSYS_ARGS = new String[] { "--checkin", "-u" };
82 private static final String BATTERY_STATS_SERVICE_NAME = "batteryinfo";
84 private static final String DUMPSYS_DATA_PATH = "/data/system/";
86 // This should probably be exposed in the API, though it's not critical
87 private static final int BATTERY_PLUGGED_NONE = 0;
89 private final Context mContext;
90 private final IBatteryStats mBatteryStats;
92 private boolean mAcOnline;
93 private boolean mUsbOnline;
94 private int mBatteryStatus;
95 private int mBatteryHealth;
96 private boolean mBatteryPresent;
97 private int mBatteryLevel;
98 private int mBatteryVoltage;
99 private int mBatteryTemperature;
100 private String mBatteryTechnology;
101 private boolean mBatteryLevelCritical;
103 private int mLastBatteryStatus;
104 private int mLastBatteryHealth;
105 private boolean mLastBatteryPresent;
106 private int mLastBatteryLevel;
107 private int mLastBatteryVoltage;
108 private int mLastBatteryTemperature;
109 private boolean mLastBatteryLevelCritical;
111 private int mLowBatteryWarningLevel;
112 private int mLowBatteryCloseWarningLevel;
114 private int mPlugType;
115 private int mLastPlugType = -1; // Extra state so we can detect first run
117 private long mDischargeStartTime;
118 private int mDischargeStartLevel;
120 private boolean mSentLowBatteryBroadcast = false;
122 public BatteryService(Context context) {
124 mBatteryStats = BatteryStatsService.getService();
126 mLowBatteryWarningLevel = mContext.getResources().getInteger(
127 com.android.internal.R.integer.config_lowBatteryWarningLevel);
128 mLowBatteryCloseWarningLevel = mContext.getResources().getInteger(
129 com.android.internal.R.integer.config_lowBatteryCloseWarningLevel);
131 mUEventObserver.startObserving("SUBSYSTEM=power_supply");
133 // set initial status
137 final boolean isPowered() {
138 // assume we are powered if battery state is unknown so the "stay on while plugged in" option will work.
139 return (mAcOnline || mUsbOnline || mBatteryStatus == BatteryManager.BATTERY_STATUS_UNKNOWN);
142 final boolean isPowered(int plugTypeSet) {
143 // assume we are powered if battery state is unknown so
144 // the "stay on while plugged in" option will work.
145 if (mBatteryStatus == BatteryManager.BATTERY_STATUS_UNKNOWN) {
148 if (plugTypeSet == 0) {
153 plugTypeBit |= BatteryManager.BATTERY_PLUGGED_AC;
156 plugTypeBit |= BatteryManager.BATTERY_PLUGGED_USB;
158 return (plugTypeSet & plugTypeBit) != 0;
161 final int getPlugType() {
165 private UEventObserver mUEventObserver = new UEventObserver() {
167 public void onUEvent(UEventObserver.UEvent event) {
172 // returns battery level as a percentage
173 final int getBatteryLevel() {
174 return mBatteryLevel;
178 // check our power situation now that it is safe to display the shutdown dialog.
182 private final void shutdownIfNoPower() {
183 // shut down gracefully if our battery is critically low and we are not powered.
184 // wait until the system has booted before attempting to display the shutdown dialog.
185 if (mBatteryLevel == 0 && !isPowered() && ActivityManagerNative.isSystemReady()) {
186 Intent intent = new Intent(Intent.ACTION_REQUEST_SHUTDOWN);
187 intent.putExtra(Intent.EXTRA_KEY_CONFIRM, false);
188 intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
189 mContext.startActivity(intent);
193 private native void native_update();
195 private synchronized final void update() {
198 boolean logOutlier = false;
199 long dischargeDuration = 0;
203 mBatteryLevelCritical = mBatteryLevel <= CRITICAL_BATTERY_LEVEL;
205 mPlugType = BatteryManager.BATTERY_PLUGGED_AC;
206 } else if (mUsbOnline) {
207 mPlugType = BatteryManager.BATTERY_PLUGGED_USB;
209 mPlugType = BATTERY_PLUGGED_NONE;
211 if (mBatteryStatus != mLastBatteryStatus ||
212 mBatteryHealth != mLastBatteryHealth ||
213 mBatteryPresent != mLastBatteryPresent ||
214 mBatteryLevel != mLastBatteryLevel ||
215 mPlugType != mLastPlugType ||
216 mBatteryVoltage != mLastBatteryVoltage ||
217 mBatteryTemperature != mLastBatteryTemperature) {
219 if (mPlugType != mLastPlugType) {
220 if (mLastPlugType == BATTERY_PLUGGED_NONE) {
221 // discharging -> charging
223 // There's no value in this data unless we've discharged at least once and the
224 // battery level has changed; so don't log until it does.
225 if (mDischargeStartTime != 0 && mDischargeStartLevel != mBatteryLevel) {
226 dischargeDuration = SystemClock.elapsedRealtime() - mDischargeStartTime;
228 EventLog.writeEvent(EventLogTags.BATTERY_DISCHARGE, dischargeDuration,
229 mDischargeStartLevel, mBatteryLevel);
230 // make sure we see a discharge event before logging again
231 mDischargeStartTime = 0;
233 } else if (mPlugType == BATTERY_PLUGGED_NONE) {
234 // charging -> discharging or we just powered up
235 mDischargeStartTime = SystemClock.elapsedRealtime();
236 mDischargeStartLevel = mBatteryLevel;
239 if (mBatteryStatus != mLastBatteryStatus ||
240 mBatteryHealth != mLastBatteryHealth ||
241 mBatteryPresent != mLastBatteryPresent ||
242 mPlugType != mLastPlugType) {
243 EventLog.writeEvent(EventLogTags.BATTERY_STATUS,
244 mBatteryStatus, mBatteryHealth, mBatteryPresent ? 1 : 0,
245 mPlugType, mBatteryTechnology);
247 if (mBatteryLevel != mLastBatteryLevel ||
248 mBatteryVoltage != mLastBatteryVoltage ||
249 mBatteryTemperature != mLastBatteryTemperature) {
250 EventLog.writeEvent(EventLogTags.BATTERY_LEVEL,
251 mBatteryLevel, mBatteryVoltage, mBatteryTemperature);
253 if (mBatteryLevel != mLastBatteryLevel && mPlugType == BATTERY_PLUGGED_NONE) {
254 // If the battery level has changed and we are on battery, update the current level.
255 // This is used for discharge cycle tracking so this shouldn't be updated while the
256 // battery is charging.
258 mBatteryStats.recordCurrentLevel(mBatteryLevel);
259 } catch (RemoteException e) {
260 // Should never happen.
263 if (mBatteryLevelCritical && !mLastBatteryLevelCritical &&
264 mPlugType == BATTERY_PLUGGED_NONE) {
265 // We want to make sure we log discharge cycle outliers
266 // if the battery is about to die.
267 dischargeDuration = SystemClock.elapsedRealtime() - mDischargeStartTime;
271 final boolean plugged = mPlugType != BATTERY_PLUGGED_NONE;
272 final boolean oldPlugged = mLastPlugType != BATTERY_PLUGGED_NONE;
274 /* The ACTION_BATTERY_LOW broadcast is sent in these situations:
275 * - is just un-plugged (previously was plugged) and battery level is
276 * less than or equal to WARNING, or
277 * - is not plugged and battery level falls to WARNING boundary
278 * (becomes <= mLowBatteryWarningLevel).
280 final boolean sendBatteryLow = !plugged
281 && mBatteryStatus != BatteryManager.BATTERY_STATUS_UNKNOWN
282 && mBatteryLevel <= mLowBatteryWarningLevel
283 && (oldPlugged || mLastBatteryLevel > mLowBatteryWarningLevel);
287 // Separate broadcast is sent for power connected / not connected
288 // since the standard intent will not wake any applications and some
289 // applications may want to have smart behavior based on this.
290 Intent statusIntent = new Intent();
291 statusIntent.setFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
292 if (mPlugType != 0 && mLastPlugType == 0) {
293 statusIntent.setAction(Intent.ACTION_POWER_CONNECTED);
294 mContext.sendBroadcast(statusIntent);
296 else if (mPlugType == 0 && mLastPlugType != 0) {
297 statusIntent.setAction(Intent.ACTION_POWER_DISCONNECTED);
298 mContext.sendBroadcast(statusIntent);
301 if (sendBatteryLow) {
302 mSentLowBatteryBroadcast = true;
303 statusIntent.setAction(Intent.ACTION_BATTERY_LOW);
304 mContext.sendBroadcast(statusIntent);
305 } else if (mSentLowBatteryBroadcast && mLastBatteryLevel >= mLowBatteryCloseWarningLevel) {
306 mSentLowBatteryBroadcast = false;
307 statusIntent.setAction(Intent.ACTION_BATTERY_OKAY);
308 mContext.sendBroadcast(statusIntent);
311 // This needs to be done after sendIntent() so that we get the lastest battery stats.
312 if (logOutlier && dischargeDuration != 0) {
313 logOutlier(dischargeDuration);
316 mLastBatteryStatus = mBatteryStatus;
317 mLastBatteryHealth = mBatteryHealth;
318 mLastBatteryPresent = mBatteryPresent;
319 mLastBatteryLevel = mBatteryLevel;
320 mLastPlugType = mPlugType;
321 mLastBatteryVoltage = mBatteryVoltage;
322 mLastBatteryTemperature = mBatteryTemperature;
323 mLastBatteryLevelCritical = mBatteryLevelCritical;
327 private final void sendIntent() {
328 // Pack up the values and broadcast them to everyone
329 Intent intent = new Intent(Intent.ACTION_BATTERY_CHANGED);
330 intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY
331 | Intent.FLAG_RECEIVER_REPLACE_PENDING);
333 mBatteryStats.setOnBattery(mPlugType == BATTERY_PLUGGED_NONE, mBatteryLevel);
334 } catch (RemoteException e) {
335 // Should never happen.
338 int icon = getIcon(mBatteryLevel);
340 intent.putExtra(BatteryManager.EXTRA_STATUS, mBatteryStatus);
341 intent.putExtra(BatteryManager.EXTRA_HEALTH, mBatteryHealth);
342 intent.putExtra(BatteryManager.EXTRA_PRESENT, mBatteryPresent);
343 intent.putExtra(BatteryManager.EXTRA_LEVEL, mBatteryLevel);
344 intent.putExtra(BatteryManager.EXTRA_SCALE, BATTERY_SCALE);
345 intent.putExtra(BatteryManager.EXTRA_ICON_SMALL, icon);
346 intent.putExtra(BatteryManager.EXTRA_PLUGGED, mPlugType);
347 intent.putExtra(BatteryManager.EXTRA_VOLTAGE, mBatteryVoltage);
348 intent.putExtra(BatteryManager.EXTRA_TEMPERATURE, mBatteryTemperature);
349 intent.putExtra(BatteryManager.EXTRA_TECHNOLOGY, mBatteryTechnology);
352 Slog.d(TAG, "updateBattery level:" + mBatteryLevel +
353 " scale:" + BATTERY_SCALE + " status:" + mBatteryStatus +
354 " health:" + mBatteryHealth + " present:" + mBatteryPresent +
355 " voltage: " + mBatteryVoltage +
356 " temperature: " + mBatteryTemperature +
357 " technology: " + mBatteryTechnology +
358 " AC powered:" + mAcOnline + " USB powered:" + mUsbOnline +
362 ActivityManagerNative.broadcastStickyIntent(intent, null);
365 private final void logBatteryStats() {
366 IBinder batteryInfoService = ServiceManager.getService(BATTERY_STATS_SERVICE_NAME);
367 if (batteryInfoService == null) return;
369 DropBoxManager db = (DropBoxManager) mContext.getSystemService(Context.DROPBOX_SERVICE);
370 if (db == null || !db.isTagEnabled("BATTERY_DISCHARGE_INFO")) return;
372 File dumpFile = null;
373 FileOutputStream dumpStream = null;
375 // dump the service to a file
376 dumpFile = new File(DUMPSYS_DATA_PATH + BATTERY_STATS_SERVICE_NAME + ".dump");
377 dumpStream = new FileOutputStream(dumpFile);
378 batteryInfoService.dump(dumpStream.getFD(), DUMPSYS_ARGS);
379 dumpStream.getFD().sync();
381 // add dump file to drop box
382 db.addFile("BATTERY_DISCHARGE_INFO", dumpFile, DropBoxManager.IS_TEXT);
383 } catch (RemoteException e) {
384 Slog.e(TAG, "failed to dump battery service", e);
385 } catch (IOException e) {
386 Slog.e(TAG, "failed to write dumpsys file", e);
388 // make sure we clean up
389 if (dumpStream != null) {
392 } catch (IOException e) {
393 Slog.e(TAG, "failed to close dumpsys output stream");
396 if (dumpFile != null && !dumpFile.delete()) {
397 Slog.e(TAG, "failed to delete temporary dumpsys file: "
398 + dumpFile.getAbsolutePath());
403 private final void logOutlier(long duration) {
404 ContentResolver cr = mContext.getContentResolver();
405 String dischargeThresholdString = Settings.Secure.getString(cr,
406 Settings.Secure.BATTERY_DISCHARGE_THRESHOLD);
407 String durationThresholdString = Settings.Secure.getString(cr,
408 Settings.Secure.BATTERY_DISCHARGE_DURATION_THRESHOLD);
410 if (dischargeThresholdString != null && durationThresholdString != null) {
412 long durationThreshold = Long.parseLong(durationThresholdString);
413 int dischargeThreshold = Integer.parseInt(dischargeThresholdString);
414 if (duration <= durationThreshold &&
415 mDischargeStartLevel - mBatteryLevel >= dischargeThreshold) {
416 // If the discharge cycle is bad enough we want to know about it.
419 if (LOCAL_LOGV) Slog.v(TAG, "duration threshold: " + durationThreshold +
420 " discharge threshold: " + dischargeThreshold);
421 if (LOCAL_LOGV) Slog.v(TAG, "duration: " + duration + " discharge: " +
422 (mDischargeStartLevel - mBatteryLevel));
423 } catch (NumberFormatException e) {
424 Slog.e(TAG, "Invalid DischargeThresholds GService string: " +
425 durationThresholdString + " or " + dischargeThresholdString);
431 private final int getIcon(int level) {
432 if (mBatteryStatus == BatteryManager.BATTERY_STATUS_CHARGING) {
433 return com.android.internal.R.drawable.stat_sys_battery_charge;
434 } else if (mBatteryStatus == BatteryManager.BATTERY_STATUS_DISCHARGING ||
435 mBatteryStatus == BatteryManager.BATTERY_STATUS_NOT_CHARGING ||
436 mBatteryStatus == BatteryManager.BATTERY_STATUS_FULL) {
437 return com.android.internal.R.drawable.stat_sys_battery;
439 return com.android.internal.R.drawable.stat_sys_battery_unknown;
444 protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
445 if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DUMP)
446 != PackageManager.PERMISSION_GRANTED) {
448 pw.println("Permission Denial: can't dump Battery service from from pid="
449 + Binder.getCallingPid()
450 + ", uid=" + Binder.getCallingUid());
454 synchronized (this) {
455 pw.println("Current Battery Service state:");
456 pw.println(" AC powered: " + mAcOnline);
457 pw.println(" USB powered: " + mUsbOnline);
458 pw.println(" status: " + mBatteryStatus);
459 pw.println(" health: " + mBatteryHealth);
460 pw.println(" present: " + mBatteryPresent);
461 pw.println(" level: " + mBatteryLevel);
462 pw.println(" scale: " + BATTERY_SCALE);
463 pw.println(" voltage:" + mBatteryVoltage);
464 pw.println(" temperature: " + mBatteryTemperature);
465 pw.println(" technology: " + mBatteryTechnology);