/*
|
* Copyright (C) 2006 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.server;
|
|
import static com.android.internal.logging.nano.MetricsProto.MetricsEvent;
|
|
import android.app.ActivityManager;
|
import android.app.ActivityManagerInternal;
|
import android.content.ContentResolver;
|
import android.content.Context;
|
import android.content.Intent;
|
import android.database.ContentObserver;
|
import android.hardware.health.V1_0.HealthInfo;
|
import android.hardware.health.V2_0.IHealth;
|
import android.hardware.health.V2_0.IHealthInfoCallback;
|
import android.hardware.health.V2_0.Result;
|
import android.hidl.manager.V1_0.IServiceManager;
|
import android.hidl.manager.V1_0.IServiceNotification;
|
import android.metrics.LogMaker;
|
import android.os.BatteryManager;
|
import android.os.BatteryManagerInternal;
|
import android.os.BatteryProperty;
|
import android.os.BatteryStats;
|
import android.os.SystemProperties;
|
import android.os.Binder;
|
import android.os.Bundle;
|
import android.os.DropBoxManager;
|
import android.os.FileUtils;
|
import android.os.Handler;
|
import android.os.HandlerThread;
|
import android.os.IBatteryPropertiesRegistrar;
|
import android.os.IBinder;
|
import android.os.OsProtoEnums;
|
import android.os.PowerManager;
|
import android.os.RemoteException;
|
import android.os.ResultReceiver;
|
import android.os.ServiceManager;
|
import android.os.ShellCallback;
|
import android.os.ShellCommand;
|
import android.os.SystemClock;
|
import android.os.Trace;
|
import android.os.UEventObserver;
|
import android.os.UserHandle;
|
import android.provider.Settings;
|
import android.service.battery.BatteryServiceDumpProto;
|
import android.util.EventLog;
|
import android.util.MutableInt;
|
import android.util.Slog;
|
import android.util.Log;
|
import android.util.proto.ProtoOutputStream;
|
|
import com.android.internal.annotations.VisibleForTesting;
|
import com.android.internal.app.IBatteryStats;
|
import com.android.internal.logging.MetricsLogger;
|
import com.android.internal.util.DumpUtils;
|
import com.android.server.am.BatteryStatsService;
|
import com.android.server.lights.Light;
|
import com.android.server.lights.LightsManager;
|
|
import java.io.File;
|
import java.io.FileDescriptor;
|
import java.io.FileOutputStream;
|
import java.io.IOException;
|
import java.io.PrintWriter;
|
import java.util.ArrayDeque;
|
import java.util.ArrayList;
|
import java.util.Arrays;
|
import java.util.List;
|
import java.util.NoSuchElementException;
|
import java.util.Objects;
|
import java.util.concurrent.atomic.AtomicReference;
|
|
/**
|
* <p>BatteryService monitors the charging status, and charge level of the device
|
* battery. When these values change this service broadcasts the new values
|
* to all {@link android.content.BroadcastReceiver IntentReceivers} that are
|
* watching the {@link android.content.Intent#ACTION_BATTERY_CHANGED
|
* BATTERY_CHANGED} action.</p>
|
* <p>The new values are stored in the Intent data and can be retrieved by
|
* calling {@link android.content.Intent#getExtra Intent.getExtra} with the
|
* following keys:</p>
|
* <p>"scale" - int, the maximum value for the charge level</p>
|
* <p>"level" - int, charge level, from 0 through "scale" inclusive</p>
|
* <p>"status" - String, the current charging status.<br />
|
* <p>"health" - String, the current battery health.<br />
|
* <p>"present" - boolean, true if the battery is present<br />
|
* <p>"icon-small" - int, suggested small icon to use for this state</p>
|
* <p>"plugged" - int, 0 if the device is not plugged in; 1 if plugged
|
* into an AC power adapter; 2 if plugged in via USB.</p>
|
* <p>"voltage" - int, current battery voltage in millivolts</p>
|
* <p>"temperature" - int, current battery temperature in tenths of
|
* a degree Centigrade</p>
|
* <p>"technology" - String, the type of battery installed, e.g. "Li-ion"</p>
|
*
|
* <p>
|
* The battery service may be called by the power manager while holding its locks so
|
* we take care to post all outcalls into the activity manager to a handler.
|
*
|
* FIXME: Ideally the power manager would perform all of its calls into the battery
|
* service asynchronously itself.
|
* </p>
|
*/
|
public final class BatteryService extends SystemService {
|
private static final String TAG = BatteryService.class.getSimpleName();
|
|
private static final boolean DEBUG = false;
|
|
private static final int BATTERY_SCALE = 100; // battery capacity is a percentage
|
|
private static final long HEALTH_HAL_WAIT_MS = 1000;
|
private static final long BATTERY_LEVEL_CHANGE_THROTTLE_MS = 60_000;
|
private static final int MAX_BATTERY_LEVELS_QUEUE_SIZE = 100;
|
|
// Used locally for determining when to make a last ditch effort to log
|
// discharge stats before the device dies.
|
private int mCriticalBatteryLevel;
|
|
// TODO: Current args don't work since "--unplugged" flag was purposefully removed.
|
private static final String[] DUMPSYS_ARGS = new String[] { "--checkin", "--unplugged" };
|
|
private static final String DUMPSYS_DATA_PATH = "/data/system/";
|
|
// This should probably be exposed in the API, though it's not critical
|
private static final int BATTERY_PLUGGED_NONE = OsProtoEnums.BATTERY_PLUGGED_NONE; // = 0
|
|
private final Context mContext;
|
private final IBatteryStats mBatteryStats;
|
BinderService mBinderService;
|
private final Handler mHandler;
|
|
private final Object mLock = new Object();
|
|
private HealthInfo mHealthInfo;
|
private final HealthInfo mLastHealthInfo = new HealthInfo();
|
private boolean mBatteryLevelCritical;
|
private int mLastBatteryStatus;
|
private int mLastBatteryHealth;
|
private boolean mLastBatteryPresent;
|
private int mLastBatteryLevel;
|
private int mLastBatteryVoltage;
|
private int mLastBatteryTemperature;
|
private boolean mLastBatteryLevelCritical;
|
private int mLastMaxChargingCurrent;
|
private int mLastMaxChargingVoltage;
|
private int mLastChargeCounter;
|
|
private int mSequence = 1;
|
|
private int mInvalidCharger;
|
private int mLastInvalidCharger;
|
|
private int mLowBatteryWarningLevel;
|
private int mLowBatteryCloseWarningLevel;
|
private int mShutdownBatteryTemperature;
|
|
private int mPlugType;
|
private int mLastPlugType = -1; // Extra state so we can detect first run
|
|
private boolean mBatteryLevelLow;
|
|
private long mDischargeStartTime;
|
private int mDischargeStartLevel;
|
|
private long mChargeStartTime;
|
private int mChargeStartLevel;
|
|
private boolean mUpdatesStopped;
|
|
private Led mLed;
|
|
private boolean mSentLowBatteryBroadcast = false;
|
|
private ActivityManagerInternal mActivityManagerInternal;
|
|
private HealthServiceWrapper mHealthServiceWrapper;
|
private HealthHalCallback mHealthHalCallback;
|
private BatteryPropertiesRegistrar mBatteryPropertiesRegistrar;
|
private ArrayDeque<Bundle> mBatteryLevelsEventQueue;
|
private long mLastBatteryLevelChangedSentMs;
|
|
private MetricsLogger mMetricsLogger;
|
|
public BatteryService(Context context) {
|
super(context);
|
|
mContext = context;
|
mHandler = new Handler(true /*async*/);
|
mLed = new Led(context, getLocalService(LightsManager.class));
|
mBatteryStats = BatteryStatsService.getService();
|
mActivityManagerInternal = LocalServices.getService(ActivityManagerInternal.class);
|
|
mCriticalBatteryLevel = mContext.getResources().getInteger(
|
com.android.internal.R.integer.config_criticalBatteryWarningLevel);
|
mLowBatteryWarningLevel = mContext.getResources().getInteger(
|
com.android.internal.R.integer.config_lowBatteryWarningLevel);
|
mLowBatteryCloseWarningLevel = mLowBatteryWarningLevel + mContext.getResources().getInteger(
|
com.android.internal.R.integer.config_lowBatteryCloseWarningBump);
|
mShutdownBatteryTemperature = mContext.getResources().getInteger(
|
com.android.internal.R.integer.config_shutdownBatteryTemperature);
|
|
mBatteryLevelsEventQueue = new ArrayDeque<>();
|
mMetricsLogger = new MetricsLogger();
|
|
// watch for invalid charger messages if the invalid_charger switch exists
|
if (new File("/sys/devices/virtual/switch/invalid_charger/state").exists()) {
|
UEventObserver invalidChargerObserver = new UEventObserver() {
|
@Override
|
public void onUEvent(UEvent event) {
|
final int invalidCharger = "1".equals(event.get("SWITCH_STATE")) ? 1 : 0;
|
synchronized (mLock) {
|
if (mInvalidCharger != invalidCharger) {
|
mInvalidCharger = invalidCharger;
|
}
|
}
|
}
|
};
|
invalidChargerObserver.startObserving(
|
"DEVPATH=/devices/virtual/switch/invalid_charger");
|
}
|
}
|
|
@Override
|
public void onStart() {
|
registerHealthCallback();
|
|
mBinderService = new BinderService();
|
publishBinderService("battery", mBinderService);
|
mBatteryPropertiesRegistrar = new BatteryPropertiesRegistrar();
|
publishBinderService("batteryproperties", mBatteryPropertiesRegistrar);
|
publishLocalService(BatteryManagerInternal.class, new LocalService());
|
}
|
|
@Override
|
public void onBootPhase(int phase) {
|
if (phase == PHASE_ACTIVITY_MANAGER_READY) {
|
// check our power situation now that it is safe to display the shutdown dialog.
|
synchronized (mLock) {
|
ContentObserver obs = new ContentObserver(mHandler) {
|
@Override
|
public void onChange(boolean selfChange) {
|
synchronized (mLock) {
|
updateBatteryWarningLevelLocked();
|
}
|
}
|
};
|
final ContentResolver resolver = mContext.getContentResolver();
|
resolver.registerContentObserver(Settings.Global.getUriFor(
|
Settings.Global.LOW_POWER_MODE_TRIGGER_LEVEL),
|
false, obs, UserHandle.USER_ALL);
|
updateBatteryWarningLevelLocked();
|
}
|
}
|
}
|
|
private void registerHealthCallback() {
|
traceBegin("HealthInitWrapper");
|
mHealthServiceWrapper = new HealthServiceWrapper();
|
mHealthHalCallback = new HealthHalCallback();
|
// IHealth is lazily retrieved.
|
try {
|
mHealthServiceWrapper.init(mHealthHalCallback,
|
new HealthServiceWrapper.IServiceManagerSupplier() {},
|
new HealthServiceWrapper.IHealthSupplier() {});
|
} catch (RemoteException ex) {
|
Slog.e(TAG, "health: cannot register callback. (RemoteException)");
|
throw ex.rethrowFromSystemServer();
|
} catch (NoSuchElementException ex) {
|
Slog.e(TAG, "health: cannot register callback. (no supported health HAL service)");
|
throw ex;
|
} finally {
|
traceEnd();
|
}
|
|
traceBegin("HealthInitWaitUpdate");
|
// init register for new service notifications, and IServiceManager should return the
|
// existing service in a near future. Wait for this.update() to instantiate
|
// the initial mHealthInfo.
|
long beforeWait = SystemClock.uptimeMillis();
|
synchronized (mLock) {
|
while (mHealthInfo == null) {
|
Slog.i(TAG, "health: Waited " + (SystemClock.uptimeMillis() - beforeWait) +
|
"ms for callbacks. Waiting another " + HEALTH_HAL_WAIT_MS + " ms...");
|
try {
|
mLock.wait(HEALTH_HAL_WAIT_MS);
|
} catch (InterruptedException ex) {
|
Slog.i(TAG, "health: InterruptedException when waiting for update. "
|
+ " Continuing...");
|
}
|
}
|
}
|
|
Slog.i(TAG, "health: Waited " + (SystemClock.uptimeMillis() - beforeWait)
|
+ "ms and received the update.");
|
traceEnd();
|
}
|
|
private void updateBatteryWarningLevelLocked() {
|
final ContentResolver resolver = mContext.getContentResolver();
|
int defWarnLevel = mContext.getResources().getInteger(
|
com.android.internal.R.integer.config_lowBatteryWarningLevel);
|
mLowBatteryWarningLevel = Settings.Global.getInt(resolver,
|
Settings.Global.LOW_POWER_MODE_TRIGGER_LEVEL, defWarnLevel);
|
if (mLowBatteryWarningLevel == 0) {
|
mLowBatteryWarningLevel = defWarnLevel;
|
}
|
if (mLowBatteryWarningLevel < mCriticalBatteryLevel) {
|
mLowBatteryWarningLevel = mCriticalBatteryLevel;
|
}
|
mLowBatteryCloseWarningLevel = mLowBatteryWarningLevel + mContext.getResources().getInteger(
|
com.android.internal.R.integer.config_lowBatteryCloseWarningBump);
|
processValuesLocked(true);
|
}
|
|
private boolean isPoweredLocked(int plugTypeSet) {
|
// assume we are powered if battery state is unknown so
|
// the "stay on while plugged in" option will work.
|
if (mHealthInfo.batteryStatus == BatteryManager.BATTERY_STATUS_UNKNOWN) {
|
return true;
|
}
|
if ((plugTypeSet & BatteryManager.BATTERY_PLUGGED_AC) != 0 && mHealthInfo.chargerAcOnline) {
|
return true;
|
}
|
if ((plugTypeSet & BatteryManager.BATTERY_PLUGGED_USB) != 0 && mHealthInfo.chargerUsbOnline) {
|
return true;
|
}
|
if ((plugTypeSet & BatteryManager.BATTERY_PLUGGED_WIRELESS) != 0 && mHealthInfo.chargerWirelessOnline) {
|
return true;
|
}
|
return false;
|
}
|
|
private boolean shouldSendBatteryLowLocked() {
|
final boolean plugged = mPlugType != BATTERY_PLUGGED_NONE;
|
final boolean oldPlugged = mLastPlugType != BATTERY_PLUGGED_NONE;
|
|
/* The ACTION_BATTERY_LOW broadcast is sent in these situations:
|
* - is just un-plugged (previously was plugged) and battery level is
|
* less than or equal to WARNING, or
|
* - is not plugged and battery level falls to WARNING boundary
|
* (becomes <= mLowBatteryWarningLevel).
|
*/
|
return !plugged
|
&& mHealthInfo.batteryStatus != BatteryManager.BATTERY_STATUS_UNKNOWN
|
&& mHealthInfo.batteryLevel <= mLowBatteryWarningLevel
|
&& (oldPlugged || mLastBatteryLevel > mLowBatteryWarningLevel);
|
}
|
|
private boolean shouldShutdownLocked() {
|
if (mHealthInfo.batteryLevel > 0) {
|
return false;
|
}
|
|
// Battery-less devices should not shutdown.
|
if (!mHealthInfo.batteryPresent) {
|
return false;
|
}
|
|
// If battery state is not CHARGING, shutdown.
|
// - If battery present and state == unknown, this is an unexpected error state.
|
// - If level <= 0 and state == full, this is also an unexpected state
|
// - All other states (NOT_CHARGING, DISCHARGING) means it is not charging.
|
return mHealthInfo.batteryStatus != BatteryManager.BATTERY_STATUS_CHARGING;
|
}
|
|
private void shutdownIfNoPowerLocked() {
|
// shut down gracefully if our battery is critically low and we are not powered.
|
// wait until the system has booted before attempting to display the shutdown dialog.
|
if (shouldShutdownLocked()) {
|
mHandler.post(new Runnable() {
|
@Override
|
public void run() {
|
if (mActivityManagerInternal.isSystemReady()) {
|
Intent intent = new Intent(Intent.ACTION_REQUEST_SHUTDOWN);
|
intent.putExtra(Intent.EXTRA_KEY_CONFIRM, false);
|
intent.putExtra(Intent.EXTRA_REASON,
|
PowerManager.SHUTDOWN_LOW_BATTERY);
|
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
|
mContext.startActivityAsUser(intent, UserHandle.CURRENT);
|
}
|
}
|
});
|
}
|
}
|
|
private void shutdownIfOverTempLocked() {
|
// shut down gracefully if temperature is too high (> 68.0C by default)
|
// wait until the system has booted before attempting to display the
|
// shutdown dialog.
|
if (mHealthInfo.batteryTemperature > mShutdownBatteryTemperature) {
|
mHandler.post(new Runnable() {
|
@Override
|
public void run() {
|
if (mActivityManagerInternal.isSystemReady()) {
|
Intent intent = new Intent(Intent.ACTION_REQUEST_SHUTDOWN);
|
intent.putExtra(Intent.EXTRA_KEY_CONFIRM, false);
|
intent.putExtra(Intent.EXTRA_REASON,
|
PowerManager.SHUTDOWN_BATTERY_THERMAL_STATE);
|
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
|
mContext.startActivityAsUser(intent, UserHandle.CURRENT);
|
}
|
}
|
});
|
}
|
}
|
|
private void update(android.hardware.health.V2_0.HealthInfo info) {
|
traceBegin("HealthInfoUpdate");
|
|
Trace.traceCounter(Trace.TRACE_TAG_POWER, "BatteryChargeCounter",
|
info.legacy.batteryChargeCounter);
|
Trace.traceCounter(Trace.TRACE_TAG_POWER, "BatteryCurrent",
|
info.legacy.batteryCurrent);
|
|
synchronized (mLock) {
|
if (!mUpdatesStopped) {
|
mHealthInfo = info.legacy;
|
// Process the new values.
|
processValuesLocked(false);
|
mLock.notifyAll(); // for any waiters on new info
|
} else {
|
copy(mLastHealthInfo, info.legacy);
|
}
|
}
|
traceEnd();
|
}
|
|
private static void copy(HealthInfo dst, HealthInfo src) {
|
dst.chargerAcOnline = src.chargerAcOnline;
|
dst.chargerUsbOnline = src.chargerUsbOnline;
|
dst.chargerWirelessOnline = src.chargerWirelessOnline;
|
dst.maxChargingCurrent = src.maxChargingCurrent;
|
dst.maxChargingVoltage = src.maxChargingVoltage;
|
dst.batteryStatus = src.batteryStatus;
|
dst.batteryHealth = src.batteryHealth;
|
dst.batteryPresent = src.batteryPresent;
|
dst.batteryLevel = src.batteryLevel;
|
dst.batteryVoltage = src.batteryVoltage;
|
dst.batteryTemperature = src.batteryTemperature;
|
dst.batteryCurrent = src.batteryCurrent;
|
dst.batteryCycleCount = src.batteryCycleCount;
|
dst.batteryFullCharge = src.batteryFullCharge;
|
dst.batteryChargeCounter = src.batteryChargeCounter;
|
dst.batteryTechnology = src.batteryTechnology;
|
}
|
|
private void processValuesLocked(boolean force) {
|
boolean logOutlier = false;
|
long dischargeDuration = 0;
|
|
mBatteryLevelCritical =
|
mHealthInfo.batteryStatus != BatteryManager.BATTERY_STATUS_UNKNOWN
|
&& mHealthInfo.batteryLevel <= mCriticalBatteryLevel;
|
if (mHealthInfo.chargerAcOnline) {
|
mPlugType = BatteryManager.BATTERY_PLUGGED_AC;
|
} else if (mHealthInfo.chargerUsbOnline) {
|
mPlugType = BatteryManager.BATTERY_PLUGGED_USB;
|
} else if (mHealthInfo.chargerWirelessOnline) {
|
mPlugType = BatteryManager.BATTERY_PLUGGED_WIRELESS;
|
} else {
|
mPlugType = BATTERY_PLUGGED_NONE;
|
}
|
|
if (DEBUG) {
|
Slog.d(TAG, "Processing new values: "
|
+ "info=" + mHealthInfo
|
+ ", mBatteryLevelCritical=" + mBatteryLevelCritical
|
+ ", mPlugType=" + mPlugType);
|
}
|
|
// Let the battery stats keep track of the current level.
|
try {
|
mBatteryStats.setBatteryState(mHealthInfo.batteryStatus, mHealthInfo.batteryHealth,
|
mPlugType, mHealthInfo.batteryLevel, mHealthInfo.batteryTemperature,
|
mHealthInfo.batteryVoltage, mHealthInfo.batteryChargeCounter,
|
mHealthInfo.batteryFullCharge);
|
} catch (RemoteException e) {
|
// Should never happen.
|
}
|
|
shutdownIfNoPowerLocked();
|
shutdownIfOverTempLocked();
|
|
if (force || (mHealthInfo.batteryStatus != mLastBatteryStatus ||
|
mHealthInfo.batteryHealth != mLastBatteryHealth ||
|
mHealthInfo.batteryPresent != mLastBatteryPresent ||
|
mHealthInfo.batteryLevel != mLastBatteryLevel ||
|
mPlugType != mLastPlugType ||
|
mHealthInfo.batteryVoltage != mLastBatteryVoltage ||
|
mHealthInfo.batteryTemperature != mLastBatteryTemperature ||
|
mHealthInfo.maxChargingCurrent != mLastMaxChargingCurrent ||
|
mHealthInfo.maxChargingVoltage != mLastMaxChargingVoltage ||
|
mHealthInfo.batteryChargeCounter != mLastChargeCounter ||
|
mInvalidCharger != mLastInvalidCharger)) {
|
|
if (mPlugType != mLastPlugType) {
|
if (mLastPlugType == BATTERY_PLUGGED_NONE) {
|
// discharging -> charging
|
mChargeStartLevel = mHealthInfo.batteryLevel;
|
mChargeStartTime = SystemClock.elapsedRealtime();
|
|
final LogMaker builder = new LogMaker(MetricsEvent.ACTION_CHARGE);
|
builder.setType(MetricsEvent.TYPE_ACTION);
|
builder.addTaggedData(MetricsEvent.FIELD_PLUG_TYPE, mPlugType);
|
builder.addTaggedData(MetricsEvent.FIELD_BATTERY_LEVEL_START,
|
mHealthInfo.batteryLevel);
|
mMetricsLogger.write(builder);
|
|
// There's no value in this data unless we've discharged at least once and the
|
// battery level has changed; so don't log until it does.
|
if (mDischargeStartTime != 0 && mDischargeStartLevel != mHealthInfo.batteryLevel) {
|
dischargeDuration = SystemClock.elapsedRealtime() - mDischargeStartTime;
|
logOutlier = true;
|
EventLog.writeEvent(EventLogTags.BATTERY_DISCHARGE, dischargeDuration,
|
mDischargeStartLevel, mHealthInfo.batteryLevel);
|
// make sure we see a discharge event before logging again
|
mDischargeStartTime = 0;
|
}
|
} else if (mPlugType == BATTERY_PLUGGED_NONE) {
|
// charging -> discharging or we just powered up
|
mDischargeStartTime = SystemClock.elapsedRealtime();
|
mDischargeStartLevel = mHealthInfo.batteryLevel;
|
|
long chargeDuration = SystemClock.elapsedRealtime() - mChargeStartTime;
|
if (mChargeStartTime != 0 && chargeDuration != 0) {
|
final LogMaker builder = new LogMaker(MetricsEvent.ACTION_CHARGE);
|
builder.setType(MetricsEvent.TYPE_DISMISS);
|
builder.addTaggedData(MetricsEvent.FIELD_PLUG_TYPE, mLastPlugType);
|
builder.addTaggedData(MetricsEvent.FIELD_CHARGING_DURATION_MILLIS,
|
chargeDuration);
|
builder.addTaggedData(MetricsEvent.FIELD_BATTERY_LEVEL_START,
|
mChargeStartLevel);
|
builder.addTaggedData(MetricsEvent.FIELD_BATTERY_LEVEL_END,
|
mHealthInfo.batteryLevel);
|
mMetricsLogger.write(builder);
|
}
|
mChargeStartTime = 0;
|
}
|
}
|
if (mHealthInfo.batteryStatus != mLastBatteryStatus ||
|
mHealthInfo.batteryHealth != mLastBatteryHealth ||
|
mHealthInfo.batteryPresent != mLastBatteryPresent ||
|
mPlugType != mLastPlugType) {
|
EventLog.writeEvent(EventLogTags.BATTERY_STATUS,
|
mHealthInfo.batteryStatus, mHealthInfo.batteryHealth, mHealthInfo.batteryPresent ? 1 : 0,
|
mPlugType, mHealthInfo.batteryTechnology);
|
}
|
if (mHealthInfo.batteryLevel != mLastBatteryLevel) {
|
// Don't do this just from voltage or temperature changes, that is
|
// too noisy.
|
EventLog.writeEvent(EventLogTags.BATTERY_LEVEL,
|
mHealthInfo.batteryLevel, mHealthInfo.batteryVoltage, mHealthInfo.batteryTemperature);
|
}
|
if (mBatteryLevelCritical && !mLastBatteryLevelCritical &&
|
mPlugType == BATTERY_PLUGGED_NONE) {
|
// We want to make sure we log discharge cycle outliers
|
// if the battery is about to die.
|
dischargeDuration = SystemClock.elapsedRealtime() - mDischargeStartTime;
|
logOutlier = true;
|
}
|
|
if (!mBatteryLevelLow) {
|
// Should we now switch in to low battery mode?
|
if (mPlugType == BATTERY_PLUGGED_NONE
|
&& mHealthInfo.batteryStatus !=
|
BatteryManager.BATTERY_STATUS_UNKNOWN
|
&& mHealthInfo.batteryLevel <= mLowBatteryWarningLevel) {
|
mBatteryLevelLow = true;
|
}
|
} else {
|
// Should we now switch out of low battery mode?
|
if (mPlugType != BATTERY_PLUGGED_NONE) {
|
mBatteryLevelLow = false;
|
} else if (mHealthInfo.batteryLevel >= mLowBatteryCloseWarningLevel) {
|
mBatteryLevelLow = false;
|
} else if (force && mHealthInfo.batteryLevel >= mLowBatteryWarningLevel) {
|
// If being forced, the previous state doesn't matter, we will just
|
// absolutely check to see if we are now above the warning level.
|
mBatteryLevelLow = false;
|
}
|
}
|
|
mSequence++;
|
|
// Separate broadcast is sent for power connected / not connected
|
// since the standard intent will not wake any applications and some
|
// applications may want to have smart behavior based on this.
|
if (mPlugType != 0 && mLastPlugType == 0) {
|
final Intent statusIntent = new Intent(Intent.ACTION_POWER_CONNECTED);
|
statusIntent.setFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
|
statusIntent.putExtra(BatteryManager.EXTRA_SEQUENCE, mSequence);
|
mHandler.post(new Runnable() {
|
@Override
|
public void run() {
|
mContext.sendBroadcastAsUser(statusIntent, UserHandle.ALL);
|
}
|
});
|
}
|
else if (mPlugType == 0 && mLastPlugType != 0) {
|
final Intent statusIntent = new Intent(Intent.ACTION_POWER_DISCONNECTED);
|
statusIntent.setFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
|
statusIntent.putExtra(BatteryManager.EXTRA_SEQUENCE, mSequence);
|
mHandler.post(new Runnable() {
|
@Override
|
public void run() {
|
mContext.sendBroadcastAsUser(statusIntent, UserHandle.ALL);
|
}
|
});
|
}
|
|
if (shouldSendBatteryLowLocked()) {
|
mSentLowBatteryBroadcast = true;
|
final Intent statusIntent = new Intent(Intent.ACTION_BATTERY_LOW);
|
statusIntent.setFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
|
statusIntent.putExtra(BatteryManager.EXTRA_SEQUENCE, mSequence);
|
mHandler.post(new Runnable() {
|
@Override
|
public void run() {
|
mContext.sendBroadcastAsUser(statusIntent, UserHandle.ALL);
|
}
|
});
|
} else if (mSentLowBatteryBroadcast &&
|
mHealthInfo.batteryLevel >= mLowBatteryCloseWarningLevel) {
|
mSentLowBatteryBroadcast = false;
|
final Intent statusIntent = new Intent(Intent.ACTION_BATTERY_OKAY);
|
statusIntent.setFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
|
statusIntent.putExtra(BatteryManager.EXTRA_SEQUENCE, mSequence);
|
mHandler.post(new Runnable() {
|
@Override
|
public void run() {
|
mContext.sendBroadcastAsUser(statusIntent, UserHandle.ALL);
|
}
|
});
|
}
|
|
// We are doing this after sending the above broadcasts, so anything processing
|
// them will get the new sequence number at that point. (See for example how testing
|
// of JobScheduler's BatteryController works.)
|
sendBatteryChangedIntentLocked();
|
if (mLastBatteryLevel != mHealthInfo.batteryLevel || mLastPlugType != mPlugType) {
|
sendBatteryLevelChangedIntentLocked();
|
}
|
|
|
// Update the battery LED
|
mLed.updateLightsLocked();
|
|
// This needs to be done after sendIntent() so that we get the lastest battery stats.
|
if (logOutlier && dischargeDuration != 0) {
|
logOutlierLocked(dischargeDuration);
|
}
|
|
mLastBatteryStatus = mHealthInfo.batteryStatus;
|
mLastBatteryHealth = mHealthInfo.batteryHealth;
|
mLastBatteryPresent = mHealthInfo.batteryPresent;
|
mLastBatteryLevel = mHealthInfo.batteryLevel;
|
mLastPlugType = mPlugType;
|
mLastBatteryVoltage = mHealthInfo.batteryVoltage;
|
mLastBatteryTemperature = mHealthInfo.batteryTemperature;
|
mLastMaxChargingCurrent = mHealthInfo.maxChargingCurrent;
|
mLastMaxChargingVoltage = mHealthInfo.maxChargingVoltage;
|
mLastChargeCounter = mHealthInfo.batteryChargeCounter;
|
mLastBatteryLevelCritical = mBatteryLevelCritical;
|
mLastInvalidCharger = mInvalidCharger;
|
}
|
}
|
|
private void sendBatteryChangedIntentLocked() {
|
// Pack up the values and broadcast them to everyone
|
final Intent intent = new Intent(Intent.ACTION_BATTERY_CHANGED);
|
intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY
|
| Intent.FLAG_RECEIVER_REPLACE_PENDING);
|
|
int icon = getIconLocked(mHealthInfo.batteryLevel);
|
|
intent.putExtra(BatteryManager.EXTRA_SEQUENCE, mSequence);
|
intent.putExtra(BatteryManager.EXTRA_STATUS, mHealthInfo.batteryStatus);
|
intent.putExtra(BatteryManager.EXTRA_HEALTH, mHealthInfo.batteryHealth);
|
intent.putExtra(BatteryManager.EXTRA_PRESENT, mHealthInfo.batteryPresent);
|
intent.putExtra(BatteryManager.EXTRA_LEVEL, mHealthInfo.batteryLevel);
|
intent.putExtra(BatteryManager.EXTRA_BATTERY_LOW, mSentLowBatteryBroadcast);
|
intent.putExtra(BatteryManager.EXTRA_SCALE, BATTERY_SCALE);
|
intent.putExtra(BatteryManager.EXTRA_ICON_SMALL, icon);
|
intent.putExtra(BatteryManager.EXTRA_PLUGGED, mPlugType);
|
intent.putExtra(BatteryManager.EXTRA_VOLTAGE, mHealthInfo.batteryVoltage);
|
intent.putExtra(BatteryManager.EXTRA_TEMPERATURE, mHealthInfo.batteryTemperature);
|
intent.putExtra(BatteryManager.EXTRA_TECHNOLOGY, mHealthInfo.batteryTechnology);
|
intent.putExtra(BatteryManager.EXTRA_INVALID_CHARGER, mInvalidCharger);
|
intent.putExtra(BatteryManager.EXTRA_MAX_CHARGING_CURRENT, mHealthInfo.maxChargingCurrent);
|
intent.putExtra(BatteryManager.EXTRA_MAX_CHARGING_VOLTAGE, mHealthInfo.maxChargingVoltage);
|
intent.putExtra(BatteryManager.EXTRA_CHARGE_COUNTER, mHealthInfo.batteryChargeCounter);
|
if (DEBUG) {
|
Slog.d(TAG, "Sending ACTION_BATTERY_CHANGED. scale:" + BATTERY_SCALE
|
+ ", info:" + mHealthInfo.toString());
|
}
|
|
mHandler.post(() -> ActivityManager.broadcastStickyIntent(intent, UserHandle.USER_ALL));
|
}
|
|
private void sendBatteryLevelChangedIntentLocked() {
|
Bundle event = new Bundle();
|
long now = SystemClock.elapsedRealtime();
|
event.putInt(BatteryManager.EXTRA_SEQUENCE, mSequence);
|
event.putInt(BatteryManager.EXTRA_STATUS, mHealthInfo.batteryStatus);
|
event.putInt(BatteryManager.EXTRA_HEALTH, mHealthInfo.batteryHealth);
|
event.putBoolean(BatteryManager.EXTRA_PRESENT, mHealthInfo.batteryPresent);
|
event.putInt(BatteryManager.EXTRA_LEVEL, mHealthInfo.batteryLevel);
|
event.putBoolean(BatteryManager.EXTRA_BATTERY_LOW, mSentLowBatteryBroadcast);
|
event.putInt(BatteryManager.EXTRA_SCALE, BATTERY_SCALE);
|
event.putInt(BatteryManager.EXTRA_PLUGGED, mPlugType);
|
event.putInt(BatteryManager.EXTRA_VOLTAGE, mHealthInfo.batteryVoltage);
|
event.putLong(BatteryManager.EXTRA_EVENT_TIMESTAMP, now);
|
|
boolean queueWasEmpty = mBatteryLevelsEventQueue.isEmpty();
|
mBatteryLevelsEventQueue.add(event);
|
// Make sure queue is bounded and doesn't exceed intent payload limits
|
if (mBatteryLevelsEventQueue.size() > MAX_BATTERY_LEVELS_QUEUE_SIZE) {
|
mBatteryLevelsEventQueue.removeFirst();
|
}
|
|
if (queueWasEmpty) {
|
// send now if last event was before throttle interval, otherwise delay
|
long delay = now - mLastBatteryLevelChangedSentMs > BATTERY_LEVEL_CHANGE_THROTTLE_MS
|
? 0 : mLastBatteryLevelChangedSentMs + BATTERY_LEVEL_CHANGE_THROTTLE_MS - now;
|
mHandler.postDelayed(this::sendEnqueuedBatteryLevelChangedEvents, delay);
|
}
|
}
|
|
private void sendEnqueuedBatteryLevelChangedEvents() {
|
ArrayList<Bundle> events;
|
synchronized (mLock) {
|
events = new ArrayList<>(mBatteryLevelsEventQueue);
|
mBatteryLevelsEventQueue.clear();
|
}
|
final Intent intent = new Intent(Intent.ACTION_BATTERY_LEVEL_CHANGED);
|
intent.addFlags(Intent.FLAG_RECEIVER_INCLUDE_BACKGROUND);
|
intent.putParcelableArrayListExtra(BatteryManager.EXTRA_EVENTS, events);
|
|
mContext.sendBroadcastAsUser(intent, UserHandle.ALL,
|
android.Manifest.permission.BATTERY_STATS);
|
mLastBatteryLevelChangedSentMs = SystemClock.elapsedRealtime();
|
}
|
|
// TODO: Current code doesn't work since "--unplugged" flag in BSS was purposefully removed.
|
private void logBatteryStatsLocked() {
|
IBinder batteryInfoService = ServiceManager.getService(BatteryStats.SERVICE_NAME);
|
if (batteryInfoService == null) return;
|
|
DropBoxManager db = (DropBoxManager) mContext.getSystemService(Context.DROPBOX_SERVICE);
|
if (db == null || !db.isTagEnabled("BATTERY_DISCHARGE_INFO")) return;
|
|
File dumpFile = null;
|
FileOutputStream dumpStream = null;
|
try {
|
// dump the service to a file
|
dumpFile = new File(DUMPSYS_DATA_PATH + BatteryStats.SERVICE_NAME + ".dump");
|
dumpStream = new FileOutputStream(dumpFile);
|
batteryInfoService.dump(dumpStream.getFD(), DUMPSYS_ARGS);
|
FileUtils.sync(dumpStream);
|
|
// add dump file to drop box
|
db.addFile("BATTERY_DISCHARGE_INFO", dumpFile, DropBoxManager.IS_TEXT);
|
} catch (RemoteException e) {
|
Slog.e(TAG, "failed to dump battery service", e);
|
} catch (IOException e) {
|
Slog.e(TAG, "failed to write dumpsys file", e);
|
} finally {
|
// make sure we clean up
|
if (dumpStream != null) {
|
try {
|
dumpStream.close();
|
} catch (IOException e) {
|
Slog.e(TAG, "failed to close dumpsys output stream");
|
}
|
}
|
if (dumpFile != null && !dumpFile.delete()) {
|
Slog.e(TAG, "failed to delete temporary dumpsys file: "
|
+ dumpFile.getAbsolutePath());
|
}
|
}
|
}
|
|
private void logOutlierLocked(long duration) {
|
ContentResolver cr = mContext.getContentResolver();
|
String dischargeThresholdString = Settings.Global.getString(cr,
|
Settings.Global.BATTERY_DISCHARGE_THRESHOLD);
|
String durationThresholdString = Settings.Global.getString(cr,
|
Settings.Global.BATTERY_DISCHARGE_DURATION_THRESHOLD);
|
|
if (dischargeThresholdString != null && durationThresholdString != null) {
|
try {
|
long durationThreshold = Long.parseLong(durationThresholdString);
|
int dischargeThreshold = Integer.parseInt(dischargeThresholdString);
|
if (duration <= durationThreshold &&
|
mDischargeStartLevel - mHealthInfo.batteryLevel >= dischargeThreshold) {
|
// If the discharge cycle is bad enough we want to know about it.
|
logBatteryStatsLocked();
|
}
|
if (DEBUG) Slog.v(TAG, "duration threshold: " + durationThreshold +
|
" discharge threshold: " + dischargeThreshold);
|
if (DEBUG) Slog.v(TAG, "duration: " + duration + " discharge: " +
|
(mDischargeStartLevel - mHealthInfo.batteryLevel));
|
} catch (NumberFormatException e) {
|
Slog.e(TAG, "Invalid DischargeThresholds GService string: " +
|
durationThresholdString + " or " + dischargeThresholdString);
|
}
|
}
|
}
|
|
private int getIconLocked(int level) {
|
if (mHealthInfo.batteryStatus == BatteryManager.BATTERY_STATUS_CHARGING) {
|
return com.android.internal.R.drawable.stat_sys_battery_charge;
|
} else if (mHealthInfo.batteryStatus == BatteryManager.BATTERY_STATUS_DISCHARGING) {
|
return com.android.internal.R.drawable.stat_sys_battery;
|
} else if (mHealthInfo.batteryStatus == BatteryManager.BATTERY_STATUS_NOT_CHARGING
|
|| mHealthInfo.batteryStatus == BatteryManager.BATTERY_STATUS_FULL) {
|
if (isPoweredLocked(BatteryManager.BATTERY_PLUGGED_ANY)
|
&& mHealthInfo.batteryLevel >= 100) {
|
return com.android.internal.R.drawable.stat_sys_battery_charge;
|
} else {
|
return com.android.internal.R.drawable.stat_sys_battery;
|
}
|
} else {
|
return com.android.internal.R.drawable.stat_sys_battery_unknown;
|
}
|
}
|
|
class Shell extends ShellCommand {
|
@Override
|
public int onCommand(String cmd) {
|
return onShellCommand(this, cmd);
|
}
|
|
@Override
|
public void onHelp() {
|
PrintWriter pw = getOutPrintWriter();
|
dumpHelp(pw);
|
}
|
}
|
|
static void dumpHelp(PrintWriter pw) {
|
pw.println("Battery service (battery) commands:");
|
pw.println(" help");
|
pw.println(" Print this help text.");
|
pw.println(" set [-f] [ac|usb|wireless|status|level|temp|present|invalid] <value>");
|
pw.println(" Force a battery property value, freezing battery state.");
|
pw.println(" -f: force a battery change broadcast be sent, prints new sequence.");
|
pw.println(" unplug [-f]");
|
pw.println(" Force battery unplugged, freezing battery state.");
|
pw.println(" -f: force a battery change broadcast be sent, prints new sequence.");
|
pw.println(" reset [-f]");
|
pw.println(" Unfreeze battery state, returning to current hardware values.");
|
pw.println(" -f: force a battery change broadcast be sent, prints new sequence.");
|
}
|
|
static final int OPTION_FORCE_UPDATE = 1<<0;
|
|
int parseOptions(Shell shell) {
|
String opt;
|
int opts = 0;
|
while ((opt = shell.getNextOption()) != null) {
|
if ("-f".equals(opt)) {
|
opts |= OPTION_FORCE_UPDATE;
|
}
|
}
|
return opts;
|
}
|
|
int onShellCommand(Shell shell, String cmd) {
|
if (cmd == null) {
|
return shell.handleDefaultCommands(cmd);
|
}
|
PrintWriter pw = shell.getOutPrintWriter();
|
switch (cmd) {
|
case "unplug": {
|
int opts = parseOptions(shell);
|
getContext().enforceCallingOrSelfPermission(
|
android.Manifest.permission.DEVICE_POWER, null);
|
if (!mUpdatesStopped) {
|
copy(mLastHealthInfo, mHealthInfo);
|
}
|
mHealthInfo.chargerAcOnline = false;
|
mHealthInfo.chargerUsbOnline = false;
|
mHealthInfo.chargerWirelessOnline = false;
|
long ident = Binder.clearCallingIdentity();
|
try {
|
mUpdatesStopped = true;
|
processValuesFromShellLocked(pw, opts);
|
} finally {
|
Binder.restoreCallingIdentity(ident);
|
}
|
} break;
|
case "set": {
|
int opts = parseOptions(shell);
|
getContext().enforceCallingOrSelfPermission(
|
android.Manifest.permission.DEVICE_POWER, null);
|
final String key = shell.getNextArg();
|
if (key == null) {
|
pw.println("No property specified");
|
return -1;
|
|
}
|
final String value = shell.getNextArg();
|
if (value == null) {
|
pw.println("No value specified");
|
return -1;
|
|
}
|
try {
|
if (!mUpdatesStopped) {
|
copy(mLastHealthInfo, mHealthInfo);
|
}
|
boolean update = true;
|
switch (key) {
|
case "present":
|
mHealthInfo.batteryPresent = Integer.parseInt(value) != 0;
|
break;
|
case "ac":
|
mHealthInfo.chargerAcOnline = Integer.parseInt(value) != 0;
|
break;
|
case "usb":
|
mHealthInfo.chargerUsbOnline = Integer.parseInt(value) != 0;
|
break;
|
case "wireless":
|
mHealthInfo.chargerWirelessOnline = Integer.parseInt(value) != 0;
|
break;
|
case "status":
|
mHealthInfo.batteryStatus = Integer.parseInt(value);
|
break;
|
case "level":
|
mHealthInfo.batteryLevel = Integer.parseInt(value);
|
break;
|
case "counter":
|
mHealthInfo.batteryChargeCounter = Integer.parseInt(value);
|
break;
|
case "temp":
|
mHealthInfo.batteryTemperature = Integer.parseInt(value);
|
break;
|
case "invalid":
|
mInvalidCharger = Integer.parseInt(value);
|
break;
|
default:
|
pw.println("Unknown set option: " + key);
|
update = false;
|
break;
|
}
|
if (update) {
|
long ident = Binder.clearCallingIdentity();
|
try {
|
mUpdatesStopped = true;
|
processValuesFromShellLocked(pw, opts);
|
} finally {
|
Binder.restoreCallingIdentity(ident);
|
}
|
}
|
} catch (NumberFormatException ex) {
|
pw.println("Bad value: " + value);
|
return -1;
|
}
|
} break;
|
case "reset": {
|
int opts = parseOptions(shell);
|
getContext().enforceCallingOrSelfPermission(
|
android.Manifest.permission.DEVICE_POWER, null);
|
long ident = Binder.clearCallingIdentity();
|
try {
|
if (mUpdatesStopped) {
|
mUpdatesStopped = false;
|
copy(mHealthInfo, mLastHealthInfo);
|
processValuesFromShellLocked(pw, opts);
|
}
|
} finally {
|
Binder.restoreCallingIdentity(ident);
|
}
|
} break;
|
default:
|
return shell.handleDefaultCommands(cmd);
|
}
|
return 0;
|
}
|
|
private void processValuesFromShellLocked(PrintWriter pw, int opts) {
|
processValuesLocked((opts & OPTION_FORCE_UPDATE) != 0);
|
if ((opts & OPTION_FORCE_UPDATE) != 0) {
|
pw.println(mSequence);
|
}
|
}
|
|
private void dumpInternal(FileDescriptor fd, PrintWriter pw, String[] args) {
|
synchronized (mLock) {
|
if (args == null || args.length == 0 || "-a".equals(args[0])) {
|
pw.println("Current Battery Service state:");
|
if (mUpdatesStopped) {
|
pw.println(" (UPDATES STOPPED -- use 'reset' to restart)");
|
}
|
pw.println(" AC powered: " + mHealthInfo.chargerAcOnline);
|
pw.println(" USB powered: " + mHealthInfo.chargerUsbOnline);
|
pw.println(" Wireless powered: " + mHealthInfo.chargerWirelessOnline);
|
pw.println(" Max charging current: " + mHealthInfo.maxChargingCurrent);
|
pw.println(" Max charging voltage: " + mHealthInfo.maxChargingVoltage);
|
pw.println(" Charge counter: " + mHealthInfo.batteryChargeCounter);
|
pw.println(" status: " + mHealthInfo.batteryStatus);
|
pw.println(" health: " + mHealthInfo.batteryHealth);
|
pw.println(" present: " + mHealthInfo.batteryPresent);
|
pw.println(" level: " + mHealthInfo.batteryLevel);
|
pw.println(" scale: " + BATTERY_SCALE);
|
pw.println(" voltage: " + mHealthInfo.batteryVoltage);
|
pw.println(" temperature: " + mHealthInfo.batteryTemperature);
|
pw.println(" technology: " + mHealthInfo.batteryTechnology);
|
} else {
|
Shell shell = new Shell();
|
shell.exec(mBinderService, null, fd, null, args, null, new ResultReceiver(null));
|
}
|
}
|
}
|
|
private void dumpProto(FileDescriptor fd) {
|
final ProtoOutputStream proto = new ProtoOutputStream(fd);
|
|
synchronized (mLock) {
|
proto.write(BatteryServiceDumpProto.ARE_UPDATES_STOPPED, mUpdatesStopped);
|
int batteryPluggedValue = OsProtoEnums.BATTERY_PLUGGED_NONE;
|
if (mHealthInfo.chargerAcOnline) {
|
batteryPluggedValue = OsProtoEnums.BATTERY_PLUGGED_AC;
|
} else if (mHealthInfo.chargerUsbOnline) {
|
batteryPluggedValue = OsProtoEnums.BATTERY_PLUGGED_USB;
|
} else if (mHealthInfo.chargerWirelessOnline) {
|
batteryPluggedValue = OsProtoEnums.BATTERY_PLUGGED_WIRELESS;
|
}
|
proto.write(BatteryServiceDumpProto.PLUGGED, batteryPluggedValue);
|
proto.write(BatteryServiceDumpProto.MAX_CHARGING_CURRENT, mHealthInfo.maxChargingCurrent);
|
proto.write(BatteryServiceDumpProto.MAX_CHARGING_VOLTAGE, mHealthInfo.maxChargingVoltage);
|
proto.write(BatteryServiceDumpProto.CHARGE_COUNTER, mHealthInfo.batteryChargeCounter);
|
proto.write(BatteryServiceDumpProto.STATUS, mHealthInfo.batteryStatus);
|
proto.write(BatteryServiceDumpProto.HEALTH, mHealthInfo.batteryHealth);
|
proto.write(BatteryServiceDumpProto.IS_PRESENT, mHealthInfo.batteryPresent);
|
proto.write(BatteryServiceDumpProto.LEVEL, mHealthInfo.batteryLevel);
|
proto.write(BatteryServiceDumpProto.SCALE, BATTERY_SCALE);
|
proto.write(BatteryServiceDumpProto.VOLTAGE, mHealthInfo.batteryVoltage);
|
proto.write(BatteryServiceDumpProto.TEMPERATURE, mHealthInfo.batteryTemperature);
|
proto.write(BatteryServiceDumpProto.TECHNOLOGY, mHealthInfo.batteryTechnology);
|
}
|
proto.flush();
|
}
|
|
private static void traceBegin(String name) {
|
Trace.traceBegin(Trace.TRACE_TAG_SYSTEM_SERVER, name);
|
}
|
|
private static void traceEnd() {
|
Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
|
}
|
|
private final class Led {
|
private final Light mBatteryLight;
|
|
private final int mBatteryLowARGB;
|
private final int mBatteryMediumARGB;
|
private final int mBatteryFullARGB;
|
private final int mBatteryLedOn;
|
private final int mBatteryLedOff;
|
|
public Led(Context context, LightsManager lights) {
|
mBatteryLight = lights.getLight(LightsManager.LIGHT_ID_BATTERY);
|
|
mBatteryLowARGB = context.getResources().getInteger(
|
com.android.internal.R.integer.config_notificationsBatteryLowARGB);
|
mBatteryMediumARGB = context.getResources().getInteger(
|
com.android.internal.R.integer.config_notificationsBatteryMediumARGB);
|
mBatteryFullARGB = context.getResources().getInteger(
|
com.android.internal.R.integer.config_notificationsBatteryFullARGB);
|
mBatteryLedOn = context.getResources().getInteger(
|
com.android.internal.R.integer.config_notificationsBatteryLedOn);
|
mBatteryLedOff = context.getResources().getInteger(
|
com.android.internal.R.integer.config_notificationsBatteryLedOff);
|
}
|
|
/**
|
* Synchronize on BatteryService.
|
*/
|
public void updateLightsLocked() {
|
final int level = mHealthInfo.batteryLevel;
|
final int status = mHealthInfo.batteryStatus;
|
if (level < mLowBatteryWarningLevel) {
|
if (status == BatteryManager.BATTERY_STATUS_CHARGING) {
|
// Solid red when battery is charging
|
mBatteryLight.setColor(mBatteryLowARGB);
|
} else {
|
// Flash red when battery is low and not charging
|
mBatteryLight.setFlashing(mBatteryLowARGB, Light.LIGHT_FLASH_TIMED,
|
mBatteryLedOn, mBatteryLedOff);
|
}
|
} else if (status == BatteryManager.BATTERY_STATUS_CHARGING
|
|| status == BatteryManager.BATTERY_STATUS_FULL) {
|
if (status == BatteryManager.BATTERY_STATUS_FULL || level >= 90) {
|
// Solid green when full or charging and nearly full
|
mBatteryLight.setColor(mBatteryFullARGB);
|
} else {
|
// Solid orange when charging and halfway full
|
mBatteryLight.setColor(mBatteryMediumARGB);
|
}
|
} else {
|
// No lights if not charging and not low
|
mBatteryLight.turnOff();
|
}
|
}
|
}
|
|
private final class HealthHalCallback extends IHealthInfoCallback.Stub
|
implements HealthServiceWrapper.Callback {
|
@Override public void healthInfoChanged(android.hardware.health.V2_0.HealthInfo props) {
|
BatteryService.this.update(props);
|
SystemProperties.set("battery.present",props.legacy.batteryPresent+"");
|
}
|
// on new service registered
|
@Override public void onRegistration(IHealth oldService, IHealth newService,
|
String instance) {
|
if (newService == null) return;
|
|
traceBegin("HealthUnregisterCallback");
|
try {
|
if (oldService != null) {
|
int r = oldService.unregisterCallback(this);
|
if (r != Result.SUCCESS) {
|
Slog.w(TAG, "health: cannot unregister previous callback: " +
|
Result.toString(r));
|
}
|
}
|
} catch (RemoteException ex) {
|
Slog.w(TAG, "health: cannot unregister previous callback (transaction error): "
|
+ ex.getMessage());
|
} finally {
|
traceEnd();
|
}
|
|
traceBegin("HealthRegisterCallback");
|
try {
|
int r = newService.registerCallback(this);
|
if (r != Result.SUCCESS) {
|
Slog.w(TAG, "health: cannot register callback: " + Result.toString(r));
|
return;
|
}
|
// registerCallback does NOT guarantee that update is called
|
// immediately, so request a manual update here.
|
newService.update();
|
} catch (RemoteException ex) {
|
Slog.e(TAG, "health: cannot register callback (transaction error): "
|
+ ex.getMessage());
|
} finally {
|
traceEnd();
|
}
|
}
|
}
|
|
private final class BinderService extends Binder {
|
@Override protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
|
if (!DumpUtils.checkDumpPermission(mContext, TAG, pw)) return;
|
|
if (args.length > 0 && "--proto".equals(args[0])) {
|
dumpProto(fd);
|
} else {
|
dumpInternal(fd, pw, args);
|
}
|
}
|
|
@Override public void onShellCommand(FileDescriptor in, FileDescriptor out,
|
FileDescriptor err, String[] args, ShellCallback callback,
|
ResultReceiver resultReceiver) {
|
(new Shell()).exec(this, in, out, err, args, callback, resultReceiver);
|
}
|
}
|
|
// Reduced IBatteryPropertiesRegistrar that only implements getProperty for usage
|
// in BatteryManager.
|
private final class BatteryPropertiesRegistrar extends IBatteryPropertiesRegistrar.Stub {
|
@Override
|
public int getProperty(int id, final BatteryProperty prop) throws RemoteException {
|
traceBegin("HealthGetProperty");
|
try {
|
IHealth service = mHealthServiceWrapper.getLastService();
|
if (service == null) throw new RemoteException("no health service");
|
final MutableInt outResult = new MutableInt(Result.NOT_SUPPORTED);
|
switch(id) {
|
case BatteryManager.BATTERY_PROPERTY_CHARGE_COUNTER:
|
service.getChargeCounter((int result, int value) -> {
|
outResult.value = result;
|
if (result == Result.SUCCESS) prop.setLong(value);
|
});
|
break;
|
case BatteryManager.BATTERY_PROPERTY_CURRENT_NOW:
|
service.getCurrentNow((int result, int value) -> {
|
outResult.value = result;
|
if (result == Result.SUCCESS) prop.setLong(value);
|
});
|
break;
|
case BatteryManager.BATTERY_PROPERTY_CURRENT_AVERAGE:
|
service.getCurrentAverage((int result, int value) -> {
|
outResult.value = result;
|
if (result == Result.SUCCESS) prop.setLong(value);
|
});
|
break;
|
case BatteryManager.BATTERY_PROPERTY_CAPACITY:
|
service.getCapacity((int result, int value) -> {
|
outResult.value = result;
|
if (result == Result.SUCCESS) prop.setLong(value);
|
});
|
break;
|
case BatteryManager.BATTERY_PROPERTY_STATUS:
|
service.getChargeStatus((int result, int value) -> {
|
outResult.value = result;
|
if (result == Result.SUCCESS) prop.setLong(value);
|
});
|
break;
|
case BatteryManager.BATTERY_PROPERTY_ENERGY_COUNTER:
|
service.getEnergyCounter((int result, long value) -> {
|
outResult.value = result;
|
if (result == Result.SUCCESS) prop.setLong(value);
|
});
|
break;
|
}
|
return outResult.value;
|
} finally {
|
traceEnd();
|
}
|
}
|
@Override
|
public void scheduleUpdate() throws RemoteException {
|
traceBegin("HealthScheduleUpdate");
|
try {
|
IHealth service = mHealthServiceWrapper.getLastService();
|
if (service == null) throw new RemoteException("no health service");
|
service.update();
|
} finally {
|
traceEnd();
|
}
|
}
|
}
|
|
private final class LocalService extends BatteryManagerInternal {
|
@Override
|
public boolean isPowered(int plugTypeSet) {
|
synchronized (mLock) {
|
return isPoweredLocked(plugTypeSet);
|
}
|
}
|
|
@Override
|
public int getPlugType() {
|
synchronized (mLock) {
|
return mPlugType;
|
}
|
}
|
|
@Override
|
public int getBatteryLevel() {
|
synchronized (mLock) {
|
return mHealthInfo.batteryLevel;
|
}
|
}
|
|
@Override
|
public int getBatteryChargeCounter() {
|
synchronized (mLock) {
|
return mHealthInfo.batteryChargeCounter;
|
}
|
}
|
|
@Override
|
public int getBatteryFullCharge() {
|
synchronized (mLock) {
|
return mHealthInfo.batteryFullCharge;
|
}
|
}
|
|
@Override
|
public boolean getBatteryLevelLow() {
|
synchronized (mLock) {
|
return mBatteryLevelLow;
|
}
|
}
|
|
@Override
|
public int getInvalidCharger() {
|
synchronized (mLock) {
|
return mInvalidCharger;
|
}
|
}
|
}
|
|
/**
|
* HealthServiceWrapper wraps the internal IHealth service and refreshes the service when
|
* necessary.
|
*
|
* On new registration of IHealth service, {@link #onRegistration onRegistration} is called and
|
* the internal service is refreshed.
|
* On death of an existing IHealth service, the internal service is NOT cleared to avoid
|
* race condition between death notification and new service notification. Hence,
|
* a caller must check for transaction errors when calling into the service.
|
*
|
* @hide Should only be used internally.
|
*/
|
@VisibleForTesting
|
static final class HealthServiceWrapper {
|
private static final String TAG = "HealthServiceWrapper";
|
public static final String INSTANCE_HEALTHD = "backup";
|
public static final String INSTANCE_VENDOR = "default";
|
// All interesting instances, sorted by priority high -> low.
|
private static final List<String> sAllInstances =
|
Arrays.asList(INSTANCE_VENDOR, INSTANCE_HEALTHD);
|
|
private final IServiceNotification mNotification = new Notification();
|
private final HandlerThread mHandlerThread = new HandlerThread("HealthServiceRefresh");
|
// These variables are fixed after init.
|
private Callback mCallback;
|
private IHealthSupplier mHealthSupplier;
|
private String mInstanceName;
|
|
// Last IHealth service received.
|
private final AtomicReference<IHealth> mLastService = new AtomicReference<>();
|
|
/**
|
* init should be called after constructor. For testing purposes, init is not called by
|
* constructor.
|
*/
|
HealthServiceWrapper() {
|
}
|
|
IHealth getLastService() {
|
return mLastService.get();
|
}
|
|
/**
|
* Start monitoring registration of new IHealth services. Only instances that are in
|
* {@code sAllInstances} and in device / framework manifest are used. This function should
|
* only be called once.
|
*
|
* mCallback.onRegistration() is called synchronously (aka in init thread) before
|
* this method returns.
|
*
|
* @throws RemoteException transaction error when talking to IServiceManager
|
* @throws NoSuchElementException if one of the following cases:
|
* - No service manager;
|
* - none of {@code sAllInstances} are in manifests (i.e. not
|
* available on this device), or none of these instances are available to current
|
* process.
|
* @throws NullPointerException when callback is null or supplier is null
|
*/
|
void init(Callback callback,
|
IServiceManagerSupplier managerSupplier,
|
IHealthSupplier healthSupplier)
|
throws RemoteException, NoSuchElementException, NullPointerException {
|
if (callback == null || managerSupplier == null || healthSupplier == null)
|
throw new NullPointerException();
|
|
IServiceManager manager;
|
|
mCallback = callback;
|
mHealthSupplier = healthSupplier;
|
|
// Initialize mLastService and call callback for the first time (in init thread)
|
IHealth newService = null;
|
for (String name : sAllInstances) {
|
traceBegin("HealthInitGetService_" + name);
|
try {
|
newService = healthSupplier.get(name);
|
} catch (NoSuchElementException ex) {
|
/* ignored, handled below */
|
} finally {
|
traceEnd();
|
}
|
if (newService != null) {
|
mInstanceName = name;
|
mLastService.set(newService);
|
break;
|
}
|
}
|
|
if (mInstanceName == null || newService == null) {
|
throw new NoSuchElementException(String.format(
|
"No IHealth service instance among %s is available. Perhaps no permission?",
|
sAllInstances.toString()));
|
}
|
mCallback.onRegistration(null, newService, mInstanceName);
|
|
// Register for future service registrations
|
traceBegin("HealthInitRegisterNotification");
|
mHandlerThread.start();
|
try {
|
managerSupplier.get().registerForNotifications(
|
IHealth.kInterfaceName, mInstanceName, mNotification);
|
} finally {
|
traceEnd();
|
}
|
Slog.i(TAG, "health: HealthServiceWrapper listening to instance " + mInstanceName);
|
}
|
|
@VisibleForTesting
|
HandlerThread getHandlerThread() {
|
return mHandlerThread;
|
}
|
|
interface Callback {
|
/**
|
* This function is invoked asynchronously when a new and related IServiceNotification
|
* is received.
|
* @param service the recently retrieved service from IServiceManager.
|
* Can be a dead service before service notification of a new service is delivered.
|
* Implementation must handle cases for {@link RemoteException}s when calling
|
* into service.
|
* @param instance instance name.
|
*/
|
void onRegistration(IHealth oldService, IHealth newService, String instance);
|
}
|
|
/**
|
* Supplier of services.
|
* Must not return null; throw {@link NoSuchElementException} if a service is not available.
|
*/
|
interface IServiceManagerSupplier {
|
default IServiceManager get() throws NoSuchElementException, RemoteException {
|
return IServiceManager.getService();
|
}
|
}
|
/**
|
* Supplier of services.
|
* Must not return null; throw {@link NoSuchElementException} if a service is not available.
|
*/
|
interface IHealthSupplier {
|
default IHealth get(String name) throws NoSuchElementException, RemoteException {
|
return IHealth.getService(name, true /* retry */);
|
}
|
}
|
|
private class Notification extends IServiceNotification.Stub {
|
@Override
|
public final void onRegistration(String interfaceName, String instanceName,
|
boolean preexisting) {
|
if (!IHealth.kInterfaceName.equals(interfaceName)) return;
|
if (!mInstanceName.equals(instanceName)) return;
|
|
// This runnable only runs on mHandlerThread and ordering is ensured, hence
|
// no locking is needed inside the runnable.
|
mHandlerThread.getThreadHandler().post(new Runnable() {
|
@Override
|
public void run() {
|
try {
|
IHealth newService = mHealthSupplier.get(mInstanceName);
|
IHealth oldService = mLastService.getAndSet(newService);
|
|
// preexisting may be inaccurate (race). Check for equality here.
|
if (Objects.equals(newService, oldService)) return;
|
|
Slog.i(TAG, "health: new instance registered " + mInstanceName);
|
mCallback.onRegistration(oldService, newService, mInstanceName);
|
} catch (NoSuchElementException | RemoteException ex) {
|
Slog.e(TAG, "health: Cannot get instance '" + mInstanceName
|
+ "': " + ex.getMessage() + ". Perhaps no permission?");
|
}
|
}
|
});
|
}
|
}
|
}
|
}
|
