BatteryService use a.h.health.V2_0.HealthInfo instead
... of BatteryProperties, because BatteryService talks
with health HAL in hwbinder with HIDL objects.
Test: builds
Bug: 62229583
Change-Id: I21d2dc05a03c233711d5166dfa6d0b0929ecf489
diff --git a/services/core/java/com/android/server/BatteryService.java b/services/core/java/com/android/server/BatteryService.java
index 5106c8d..6d9c977 100644
--- a/services/core/java/com/android/server/BatteryService.java
+++ b/services/core/java/com/android/server/BatteryService.java
@@ -35,6 +35,7 @@
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
+import android.hardware.health.V2_0.HealthInfo;
import android.os.BatteryManager;
import android.os.BatteryManagerInternal;
import android.os.BatteryProperties;
@@ -118,8 +119,8 @@
private final Object mLock = new Object();
- private BatteryProperties mBatteryProps;
- private final BatteryProperties mLastBatteryProps = new BatteryProperties();
+ private HealthInfo mHealthInfo;
+ private final HealthInfo mLastHealthInfo = new HealthInfo();
private boolean mBatteryLevelCritical;
private int mLastBatteryStatus;
private int mLastBatteryHealth;
@@ -251,16 +252,16 @@
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 (mBatteryProps.batteryStatus == BatteryManager.BATTERY_STATUS_UNKNOWN) {
+ if (mHealthInfo.legacy.batteryStatus == BatteryManager.BATTERY_STATUS_UNKNOWN) {
return true;
}
- if ((plugTypeSet & BatteryManager.BATTERY_PLUGGED_AC) != 0 && mBatteryProps.chargerAcOnline) {
+ if ((plugTypeSet & BatteryManager.BATTERY_PLUGGED_AC) != 0 && mHealthInfo.legacy.chargerAcOnline) {
return true;
}
- if ((plugTypeSet & BatteryManager.BATTERY_PLUGGED_USB) != 0 && mBatteryProps.chargerUsbOnline) {
+ if ((plugTypeSet & BatteryManager.BATTERY_PLUGGED_USB) != 0 && mHealthInfo.legacy.chargerUsbOnline) {
return true;
}
- if ((plugTypeSet & BatteryManager.BATTERY_PLUGGED_WIRELESS) != 0 && mBatteryProps.chargerWirelessOnline) {
+ if ((plugTypeSet & BatteryManager.BATTERY_PLUGGED_WIRELESS) != 0 && mHealthInfo.legacy.chargerWirelessOnline) {
return true;
}
return false;
@@ -277,15 +278,15 @@
* (becomes <= mLowBatteryWarningLevel).
*/
return !plugged
- && mBatteryProps.batteryStatus != BatteryManager.BATTERY_STATUS_UNKNOWN
- && mBatteryProps.batteryLevel <= mLowBatteryWarningLevel
+ && mHealthInfo.legacy.batteryStatus != BatteryManager.BATTERY_STATUS_UNKNOWN
+ && mHealthInfo.legacy.batteryLevel <= mLowBatteryWarningLevel
&& (oldPlugged || mLastBatteryLevel > mLowBatteryWarningLevel);
}
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 (mBatteryProps.batteryLevel == 0 && !isPoweredLocked(BatteryManager.BATTERY_PLUGGED_ANY)) {
+ if (mHealthInfo.legacy.batteryLevel == 0 && !isPoweredLocked(BatteryManager.BATTERY_PLUGGED_ANY)) {
mHandler.post(new Runnable() {
@Override
public void run() {
@@ -306,7 +307,7 @@
// 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 (mBatteryProps.batteryTemperature > mShutdownBatteryTemperature) {
+ if (mHealthInfo.legacy.batteryTemperature > mShutdownBatteryTemperature) {
mHandler.post(new Runnable() {
@Override
public void run() {
@@ -326,25 +327,66 @@
private void update(BatteryProperties props) {
synchronized (mLock) {
if (!mUpdatesStopped) {
- mBatteryProps = props;
+ mHealthInfo = new HealthInfo();
+ copy(mHealthInfo, props);
// Process the new values.
processValuesLocked(false);
} else {
- mLastBatteryProps.set(props);
+ copy(mLastHealthInfo, props);
}
}
}
+ private static void copy(HealthInfo dst, HealthInfo src) {
+ dst.legacy.chargerAcOnline = src.legacy.chargerAcOnline;
+ dst.legacy.chargerUsbOnline = src.legacy.chargerUsbOnline;
+ dst.legacy.chargerWirelessOnline = src.legacy.chargerWirelessOnline;
+ dst.legacy.maxChargingCurrent = src.legacy.maxChargingCurrent;
+ dst.legacy.maxChargingVoltage = src.legacy.maxChargingVoltage;
+ dst.legacy.batteryStatus = src.legacy.batteryStatus;
+ dst.legacy.batteryHealth = src.legacy.batteryHealth;
+ dst.legacy.batteryPresent = src.legacy.batteryPresent;
+ dst.legacy.batteryLevel = src.legacy.batteryLevel;
+ dst.legacy.batteryVoltage = src.legacy.batteryVoltage;
+ dst.legacy.batteryTemperature = src.legacy.batteryTemperature;
+ dst.legacy.batteryCurrent = src.legacy.batteryCurrent;
+ dst.legacy.batteryCycleCount = src.legacy.batteryCycleCount;
+ dst.legacy.batteryFullCharge = src.legacy.batteryFullCharge;
+ dst.legacy.batteryChargeCounter = src.legacy.batteryChargeCounter;
+ dst.legacy.batteryTechnology = src.legacy.batteryTechnology;
+ dst.batteryCurrentAverage = src.batteryCurrentAverage;
+ dst.batteryCapacity = src.batteryCapacity;
+ dst.energyCounter = src.energyCounter;
+ }
+
+ // TODO(b/62229583): remove this function when BatteryProperties are completely replaced.
+ private static void copy(HealthInfo dst, BatteryProperties src) {
+ dst.legacy.chargerAcOnline = src.chargerAcOnline;
+ dst.legacy.chargerUsbOnline = src.chargerUsbOnline;
+ dst.legacy.chargerWirelessOnline = src.chargerWirelessOnline;
+ dst.legacy.maxChargingCurrent = src.maxChargingCurrent;
+ dst.legacy.maxChargingVoltage = src.maxChargingVoltage;
+ dst.legacy.batteryStatus = src.batteryStatus;
+ dst.legacy.batteryHealth = src.batteryHealth;
+ dst.legacy.batteryPresent = src.batteryPresent;
+ dst.legacy.batteryLevel = src.batteryLevel;
+ dst.legacy.batteryVoltage = src.batteryVoltage;
+ dst.legacy.batteryTemperature = src.batteryTemperature;
+ dst.legacy.batteryFullCharge = src.batteryFullCharge;
+ dst.legacy.batteryChargeCounter = src.batteryChargeCounter;
+ dst.legacy.batteryTechnology = src.batteryTechnology;
+ }
+
private void processValuesLocked(boolean force) {
boolean logOutlier = false;
long dischargeDuration = 0;
- mBatteryLevelCritical = (mBatteryProps.batteryLevel <= mCriticalBatteryLevel);
- if (mBatteryProps.chargerAcOnline) {
+ mBatteryLevelCritical = (mHealthInfo.legacy.batteryLevel <= mCriticalBatteryLevel);
+ if (mHealthInfo.legacy.chargerAcOnline) {
mPlugType = BatteryManager.BATTERY_PLUGGED_AC;
- } else if (mBatteryProps.chargerUsbOnline) {
+ } else if (mHealthInfo.legacy.chargerUsbOnline) {
mPlugType = BatteryManager.BATTERY_PLUGGED_USB;
- } else if (mBatteryProps.chargerWirelessOnline) {
+ } else if (mHealthInfo.legacy.chargerWirelessOnline) {
mPlugType = BatteryManager.BATTERY_PLUGGED_WIRELESS;
} else {
mPlugType = BATTERY_PLUGGED_NONE;
@@ -352,30 +394,17 @@
if (DEBUG) {
Slog.d(TAG, "Processing new values: "
- + "chargerAcOnline=" + mBatteryProps.chargerAcOnline
- + ", chargerUsbOnline=" + mBatteryProps.chargerUsbOnline
- + ", chargerWirelessOnline=" + mBatteryProps.chargerWirelessOnline
- + ", maxChargingCurrent" + mBatteryProps.maxChargingCurrent
- + ", maxChargingVoltage" + mBatteryProps.maxChargingVoltage
- + ", batteryStatus=" + mBatteryProps.batteryStatus
- + ", batteryHealth=" + mBatteryProps.batteryHealth
- + ", batteryPresent=" + mBatteryProps.batteryPresent
- + ", batteryLevel=" + mBatteryProps.batteryLevel
- + ", batteryTechnology=" + mBatteryProps.batteryTechnology
- + ", batteryVoltage=" + mBatteryProps.batteryVoltage
- + ", batteryChargeCounter=" + mBatteryProps.batteryChargeCounter
- + ", batteryFullCharge=" + mBatteryProps.batteryFullCharge
- + ", batteryTemperature=" + mBatteryProps.batteryTemperature
+ + "info=" + mHealthInfo
+ ", mBatteryLevelCritical=" + mBatteryLevelCritical
+ ", mPlugType=" + mPlugType);
}
// Let the battery stats keep track of the current level.
try {
- mBatteryStats.setBatteryState(mBatteryProps.batteryStatus, mBatteryProps.batteryHealth,
- mPlugType, mBatteryProps.batteryLevel, mBatteryProps.batteryTemperature,
- mBatteryProps.batteryVoltage, mBatteryProps.batteryChargeCounter,
- mBatteryProps.batteryFullCharge);
+ mBatteryStats.setBatteryState(mHealthInfo.legacy.batteryStatus, mHealthInfo.legacy.batteryHealth,
+ mPlugType, mHealthInfo.legacy.batteryLevel, mHealthInfo.legacy.batteryTemperature,
+ mHealthInfo.legacy.batteryVoltage, mHealthInfo.legacy.batteryChargeCounter,
+ mHealthInfo.legacy.batteryFullCharge);
} catch (RemoteException e) {
// Should never happen.
}
@@ -383,16 +412,16 @@
shutdownIfNoPowerLocked();
shutdownIfOverTempLocked();
- if (force || (mBatteryProps.batteryStatus != mLastBatteryStatus ||
- mBatteryProps.batteryHealth != mLastBatteryHealth ||
- mBatteryProps.batteryPresent != mLastBatteryPresent ||
- mBatteryProps.batteryLevel != mLastBatteryLevel ||
+ if (force || (mHealthInfo.legacy.batteryStatus != mLastBatteryStatus ||
+ mHealthInfo.legacy.batteryHealth != mLastBatteryHealth ||
+ mHealthInfo.legacy.batteryPresent != mLastBatteryPresent ||
+ mHealthInfo.legacy.batteryLevel != mLastBatteryLevel ||
mPlugType != mLastPlugType ||
- mBatteryProps.batteryVoltage != mLastBatteryVoltage ||
- mBatteryProps.batteryTemperature != mLastBatteryTemperature ||
- mBatteryProps.maxChargingCurrent != mLastMaxChargingCurrent ||
- mBatteryProps.maxChargingVoltage != mLastMaxChargingVoltage ||
- mBatteryProps.batteryChargeCounter != mLastChargeCounter ||
+ mHealthInfo.legacy.batteryVoltage != mLastBatteryVoltage ||
+ mHealthInfo.legacy.batteryTemperature != mLastBatteryTemperature ||
+ mHealthInfo.legacy.maxChargingCurrent != mLastMaxChargingCurrent ||
+ mHealthInfo.legacy.maxChargingVoltage != mLastMaxChargingVoltage ||
+ mHealthInfo.legacy.batteryChargeCounter != mLastChargeCounter ||
mInvalidCharger != mLastInvalidCharger)) {
if (mPlugType != mLastPlugType) {
@@ -401,33 +430,33 @@
// 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 != mBatteryProps.batteryLevel) {
+ if (mDischargeStartTime != 0 && mDischargeStartLevel != mHealthInfo.legacy.batteryLevel) {
dischargeDuration = SystemClock.elapsedRealtime() - mDischargeStartTime;
logOutlier = true;
EventLog.writeEvent(EventLogTags.BATTERY_DISCHARGE, dischargeDuration,
- mDischargeStartLevel, mBatteryProps.batteryLevel);
+ mDischargeStartLevel, mHealthInfo.legacy.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 = mBatteryProps.batteryLevel;
+ mDischargeStartLevel = mHealthInfo.legacy.batteryLevel;
}
}
- if (mBatteryProps.batteryStatus != mLastBatteryStatus ||
- mBatteryProps.batteryHealth != mLastBatteryHealth ||
- mBatteryProps.batteryPresent != mLastBatteryPresent ||
+ if (mHealthInfo.legacy.batteryStatus != mLastBatteryStatus ||
+ mHealthInfo.legacy.batteryHealth != mLastBatteryHealth ||
+ mHealthInfo.legacy.batteryPresent != mLastBatteryPresent ||
mPlugType != mLastPlugType) {
EventLog.writeEvent(EventLogTags.BATTERY_STATUS,
- mBatteryProps.batteryStatus, mBatteryProps.batteryHealth, mBatteryProps.batteryPresent ? 1 : 0,
- mPlugType, mBatteryProps.batteryTechnology);
+ mHealthInfo.legacy.batteryStatus, mHealthInfo.legacy.batteryHealth, mHealthInfo.legacy.batteryPresent ? 1 : 0,
+ mPlugType, mHealthInfo.legacy.batteryTechnology);
}
- if (mBatteryProps.batteryLevel != mLastBatteryLevel) {
+ if (mHealthInfo.legacy.batteryLevel != mLastBatteryLevel) {
// Don't do this just from voltage or temperature changes, that is
// too noisy.
EventLog.writeEvent(EventLogTags.BATTERY_LEVEL,
- mBatteryProps.batteryLevel, mBatteryProps.batteryVoltage, mBatteryProps.batteryTemperature);
+ mHealthInfo.legacy.batteryLevel, mHealthInfo.legacy.batteryVoltage, mHealthInfo.legacy.batteryTemperature);
}
if (mBatteryLevelCritical && !mLastBatteryLevelCritical &&
mPlugType == BATTERY_PLUGGED_NONE) {
@@ -440,16 +469,16 @@
if (!mBatteryLevelLow) {
// Should we now switch in to low battery mode?
if (mPlugType == BATTERY_PLUGGED_NONE
- && mBatteryProps.batteryLevel <= mLowBatteryWarningLevel) {
+ && mHealthInfo.legacy.batteryLevel <= mLowBatteryWarningLevel) {
mBatteryLevelLow = true;
}
} else {
// Should we now switch out of low battery mode?
if (mPlugType != BATTERY_PLUGGED_NONE) {
mBatteryLevelLow = false;
- } else if (mBatteryProps.batteryLevel >= mLowBatteryCloseWarningLevel) {
+ } else if (mHealthInfo.legacy.batteryLevel >= mLowBatteryCloseWarningLevel) {
mBatteryLevelLow = false;
- } else if (force && mBatteryProps.batteryLevel >= mLowBatteryWarningLevel) {
+ } else if (force && mHealthInfo.legacy.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;
@@ -496,7 +525,7 @@
}
});
} else if (mSentLowBatteryBroadcast &&
- mBatteryProps.batteryLevel >= mLowBatteryCloseWarningLevel) {
+ mHealthInfo.legacy.batteryLevel >= mLowBatteryCloseWarningLevel) {
mSentLowBatteryBroadcast = false;
final Intent statusIntent = new Intent(Intent.ACTION_BATTERY_OKAY);
statusIntent.setFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
@@ -522,16 +551,16 @@
logOutlierLocked(dischargeDuration);
}
- mLastBatteryStatus = mBatteryProps.batteryStatus;
- mLastBatteryHealth = mBatteryProps.batteryHealth;
- mLastBatteryPresent = mBatteryProps.batteryPresent;
- mLastBatteryLevel = mBatteryProps.batteryLevel;
+ mLastBatteryStatus = mHealthInfo.legacy.batteryStatus;
+ mLastBatteryHealth = mHealthInfo.legacy.batteryHealth;
+ mLastBatteryPresent = mHealthInfo.legacy.batteryPresent;
+ mLastBatteryLevel = mHealthInfo.legacy.batteryLevel;
mLastPlugType = mPlugType;
- mLastBatteryVoltage = mBatteryProps.batteryVoltage;
- mLastBatteryTemperature = mBatteryProps.batteryTemperature;
- mLastMaxChargingCurrent = mBatteryProps.maxChargingCurrent;
- mLastMaxChargingVoltage = mBatteryProps.maxChargingVoltage;
- mLastChargeCounter = mBatteryProps.batteryChargeCounter;
+ mLastBatteryVoltage = mHealthInfo.legacy.batteryVoltage;
+ mLastBatteryTemperature = mHealthInfo.legacy.batteryTemperature;
+ mLastMaxChargingCurrent = mHealthInfo.legacy.maxChargingCurrent;
+ mLastMaxChargingVoltage = mHealthInfo.legacy.maxChargingVoltage;
+ mLastChargeCounter = mHealthInfo.legacy.batteryChargeCounter;
mLastBatteryLevelCritical = mBatteryLevelCritical;
mLastInvalidCharger = mInvalidCharger;
}
@@ -543,38 +572,26 @@
intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY
| Intent.FLAG_RECEIVER_REPLACE_PENDING);
- int icon = getIconLocked(mBatteryProps.batteryLevel);
+ int icon = getIconLocked(mHealthInfo.legacy.batteryLevel);
intent.putExtra(BatteryManager.EXTRA_SEQUENCE, mSequence);
- intent.putExtra(BatteryManager.EXTRA_STATUS, mBatteryProps.batteryStatus);
- intent.putExtra(BatteryManager.EXTRA_HEALTH, mBatteryProps.batteryHealth);
- intent.putExtra(BatteryManager.EXTRA_PRESENT, mBatteryProps.batteryPresent);
- intent.putExtra(BatteryManager.EXTRA_LEVEL, mBatteryProps.batteryLevel);
+ intent.putExtra(BatteryManager.EXTRA_STATUS, mHealthInfo.legacy.batteryStatus);
+ intent.putExtra(BatteryManager.EXTRA_HEALTH, mHealthInfo.legacy.batteryHealth);
+ intent.putExtra(BatteryManager.EXTRA_PRESENT, mHealthInfo.legacy.batteryPresent);
+ intent.putExtra(BatteryManager.EXTRA_LEVEL, mHealthInfo.legacy.batteryLevel);
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, mBatteryProps.batteryVoltage);
- intent.putExtra(BatteryManager.EXTRA_TEMPERATURE, mBatteryProps.batteryTemperature);
- intent.putExtra(BatteryManager.EXTRA_TECHNOLOGY, mBatteryProps.batteryTechnology);
+ intent.putExtra(BatteryManager.EXTRA_VOLTAGE, mHealthInfo.legacy.batteryVoltage);
+ intent.putExtra(BatteryManager.EXTRA_TEMPERATURE, mHealthInfo.legacy.batteryTemperature);
+ intent.putExtra(BatteryManager.EXTRA_TECHNOLOGY, mHealthInfo.legacy.batteryTechnology);
intent.putExtra(BatteryManager.EXTRA_INVALID_CHARGER, mInvalidCharger);
- intent.putExtra(BatteryManager.EXTRA_MAX_CHARGING_CURRENT, mBatteryProps.maxChargingCurrent);
- intent.putExtra(BatteryManager.EXTRA_MAX_CHARGING_VOLTAGE, mBatteryProps.maxChargingVoltage);
- intent.putExtra(BatteryManager.EXTRA_CHARGE_COUNTER, mBatteryProps.batteryChargeCounter);
+ intent.putExtra(BatteryManager.EXTRA_MAX_CHARGING_CURRENT, mHealthInfo.legacy.maxChargingCurrent);
+ intent.putExtra(BatteryManager.EXTRA_MAX_CHARGING_VOLTAGE, mHealthInfo.legacy.maxChargingVoltage);
+ intent.putExtra(BatteryManager.EXTRA_CHARGE_COUNTER, mHealthInfo.legacy.batteryChargeCounter);
if (DEBUG) {
- Slog.d(TAG, "Sending ACTION_BATTERY_CHANGED. level:" + mBatteryProps.batteryLevel +
- ", scale:" + BATTERY_SCALE + ", status:" + mBatteryProps.batteryStatus +
- ", health:" + mBatteryProps.batteryHealth +
- ", present:" + mBatteryProps.batteryPresent +
- ", voltage: " + mBatteryProps.batteryVoltage +
- ", temperature: " + mBatteryProps.batteryTemperature +
- ", technology: " + mBatteryProps.batteryTechnology +
- ", AC powered:" + mBatteryProps.chargerAcOnline +
- ", USB powered:" + mBatteryProps.chargerUsbOnline +
- ", Wireless powered:" + mBatteryProps.chargerWirelessOnline +
- ", icon:" + icon + ", invalid charger:" + mInvalidCharger +
- ", maxChargingCurrent:" + mBatteryProps.maxChargingCurrent +
- ", maxChargingVoltage:" + mBatteryProps.maxChargingVoltage +
- ", chargeCounter:" + mBatteryProps.batteryChargeCounter);
+ Slog.d(TAG, "Sending ACTION_BATTERY_CHANGED. scale:" + BATTERY_SCALE
+ + ", info:" + mHealthInfo.toString());
}
mHandler.post(new Runnable() {
@@ -635,14 +652,14 @@
long durationThreshold = Long.parseLong(durationThresholdString);
int dischargeThreshold = Integer.parseInt(dischargeThresholdString);
if (duration <= durationThreshold &&
- mDischargeStartLevel - mBatteryProps.batteryLevel >= dischargeThreshold) {
+ mDischargeStartLevel - mHealthInfo.legacy.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 - mBatteryProps.batteryLevel));
+ (mDischargeStartLevel - mHealthInfo.legacy.batteryLevel));
} catch (NumberFormatException e) {
Slog.e(TAG, "Invalid DischargeThresholds GService string: " +
durationThresholdString + " or " + dischargeThresholdString);
@@ -651,14 +668,14 @@
}
private int getIconLocked(int level) {
- if (mBatteryProps.batteryStatus == BatteryManager.BATTERY_STATUS_CHARGING) {
+ if (mHealthInfo.legacy.batteryStatus == BatteryManager.BATTERY_STATUS_CHARGING) {
return com.android.internal.R.drawable.stat_sys_battery_charge;
- } else if (mBatteryProps.batteryStatus == BatteryManager.BATTERY_STATUS_DISCHARGING) {
+ } else if (mHealthInfo.legacy.batteryStatus == BatteryManager.BATTERY_STATUS_DISCHARGING) {
return com.android.internal.R.drawable.stat_sys_battery;
- } else if (mBatteryProps.batteryStatus == BatteryManager.BATTERY_STATUS_NOT_CHARGING
- || mBatteryProps.batteryStatus == BatteryManager.BATTERY_STATUS_FULL) {
+ } else if (mHealthInfo.legacy.batteryStatus == BatteryManager.BATTERY_STATUS_NOT_CHARGING
+ || mHealthInfo.legacy.batteryStatus == BatteryManager.BATTERY_STATUS_FULL) {
if (isPoweredLocked(BatteryManager.BATTERY_PLUGGED_ANY)
- && mBatteryProps.batteryLevel >= 100) {
+ && mHealthInfo.legacy.batteryLevel >= 100) {
return com.android.internal.R.drawable.stat_sys_battery_charge;
} else {
return com.android.internal.R.drawable.stat_sys_battery;
@@ -720,11 +737,11 @@
getContext().enforceCallingOrSelfPermission(
android.Manifest.permission.DEVICE_POWER, null);
if (!mUpdatesStopped) {
- mLastBatteryProps.set(mBatteryProps);
+ copy(mLastHealthInfo, mHealthInfo);
}
- mBatteryProps.chargerAcOnline = false;
- mBatteryProps.chargerUsbOnline = false;
- mBatteryProps.chargerWirelessOnline = false;
+ mHealthInfo.legacy.chargerAcOnline = false;
+ mHealthInfo.legacy.chargerUsbOnline = false;
+ mHealthInfo.legacy.chargerWirelessOnline = false;
long ident = Binder.clearCallingIdentity();
try {
mUpdatesStopped = true;
@@ -751,30 +768,30 @@
}
try {
if (!mUpdatesStopped) {
- mLastBatteryProps.set(mBatteryProps);
+ copy(mLastHealthInfo, mHealthInfo);
}
boolean update = true;
switch (key) {
case "present":
- mBatteryProps.batteryPresent = Integer.parseInt(value) != 0;
+ mHealthInfo.legacy.batteryPresent = Integer.parseInt(value) != 0;
break;
case "ac":
- mBatteryProps.chargerAcOnline = Integer.parseInt(value) != 0;
+ mHealthInfo.legacy.chargerAcOnline = Integer.parseInt(value) != 0;
break;
case "usb":
- mBatteryProps.chargerUsbOnline = Integer.parseInt(value) != 0;
+ mHealthInfo.legacy.chargerUsbOnline = Integer.parseInt(value) != 0;
break;
case "wireless":
- mBatteryProps.chargerWirelessOnline = Integer.parseInt(value) != 0;
+ mHealthInfo.legacy.chargerWirelessOnline = Integer.parseInt(value) != 0;
break;
case "status":
- mBatteryProps.batteryStatus = Integer.parseInt(value);
+ mHealthInfo.legacy.batteryStatus = Integer.parseInt(value);
break;
case "level":
- mBatteryProps.batteryLevel = Integer.parseInt(value);
+ mHealthInfo.legacy.batteryLevel = Integer.parseInt(value);
break;
case "temp":
- mBatteryProps.batteryTemperature = Integer.parseInt(value);
+ mHealthInfo.legacy.batteryTemperature = Integer.parseInt(value);
break;
case "invalid":
mInvalidCharger = Integer.parseInt(value);
@@ -806,7 +823,7 @@
try {
if (mUpdatesStopped) {
mUpdatesStopped = false;
- mBatteryProps.set(mLastBatteryProps);
+ copy(mHealthInfo, mLastHealthInfo);
processValuesFromShellLocked(pw, opts);
}
} finally {
@@ -833,20 +850,20 @@
if (mUpdatesStopped) {
pw.println(" (UPDATES STOPPED -- use 'reset' to restart)");
}
- pw.println(" AC powered: " + mBatteryProps.chargerAcOnline);
- pw.println(" USB powered: " + mBatteryProps.chargerUsbOnline);
- pw.println(" Wireless powered: " + mBatteryProps.chargerWirelessOnline);
- pw.println(" Max charging current: " + mBatteryProps.maxChargingCurrent);
- pw.println(" Max charging voltage: " + mBatteryProps.maxChargingVoltage);
- pw.println(" Charge counter: " + mBatteryProps.batteryChargeCounter);
- pw.println(" status: " + mBatteryProps.batteryStatus);
- pw.println(" health: " + mBatteryProps.batteryHealth);
- pw.println(" present: " + mBatteryProps.batteryPresent);
- pw.println(" level: " + mBatteryProps.batteryLevel);
+ pw.println(" AC powered: " + mHealthInfo.legacy.chargerAcOnline);
+ pw.println(" USB powered: " + mHealthInfo.legacy.chargerUsbOnline);
+ pw.println(" Wireless powered: " + mHealthInfo.legacy.chargerWirelessOnline);
+ pw.println(" Max charging current: " + mHealthInfo.legacy.maxChargingCurrent);
+ pw.println(" Max charging voltage: " + mHealthInfo.legacy.maxChargingVoltage);
+ pw.println(" Charge counter: " + mHealthInfo.legacy.batteryChargeCounter);
+ pw.println(" status: " + mHealthInfo.legacy.batteryStatus);
+ pw.println(" health: " + mHealthInfo.legacy.batteryHealth);
+ pw.println(" present: " + mHealthInfo.legacy.batteryPresent);
+ pw.println(" level: " + mHealthInfo.legacy.batteryLevel);
pw.println(" scale: " + BATTERY_SCALE);
- pw.println(" voltage: " + mBatteryProps.batteryVoltage);
- pw.println(" temperature: " + mBatteryProps.batteryTemperature);
- pw.println(" technology: " + mBatteryProps.batteryTechnology);
+ pw.println(" voltage: " + mHealthInfo.legacy.batteryVoltage);
+ pw.println(" temperature: " + mHealthInfo.legacy.batteryTemperature);
+ pw.println(" technology: " + mHealthInfo.legacy.batteryTechnology);
} else {
Shell shell = new Shell();
shell.exec(mBinderService, null, fd, null, args, null, new ResultReceiver(null));
@@ -860,25 +877,25 @@
synchronized (mLock) {
proto.write(BatteryServiceDumpProto.ARE_UPDATES_STOPPED, mUpdatesStopped);
int batteryPluggedValue = BatteryServiceDumpProto.BATTERY_PLUGGED_NONE;
- if (mBatteryProps.chargerAcOnline) {
+ if (mHealthInfo.legacy.chargerAcOnline) {
batteryPluggedValue = BatteryServiceDumpProto.BATTERY_PLUGGED_AC;
- } else if (mBatteryProps.chargerUsbOnline) {
+ } else if (mHealthInfo.legacy.chargerUsbOnline) {
batteryPluggedValue = BatteryServiceDumpProto.BATTERY_PLUGGED_USB;
- } else if (mBatteryProps.chargerWirelessOnline) {
+ } else if (mHealthInfo.legacy.chargerWirelessOnline) {
batteryPluggedValue = BatteryServiceDumpProto.BATTERY_PLUGGED_WIRELESS;
}
proto.write(BatteryServiceDumpProto.PLUGGED, batteryPluggedValue);
- proto.write(BatteryServiceDumpProto.MAX_CHARGING_CURRENT, mBatteryProps.maxChargingCurrent);
- proto.write(BatteryServiceDumpProto.MAX_CHARGING_VOLTAGE, mBatteryProps.maxChargingVoltage);
- proto.write(BatteryServiceDumpProto.CHARGE_COUNTER, mBatteryProps.batteryChargeCounter);
- proto.write(BatteryServiceDumpProto.STATUS, mBatteryProps.batteryStatus);
- proto.write(BatteryServiceDumpProto.HEALTH, mBatteryProps.batteryHealth);
- proto.write(BatteryServiceDumpProto.IS_PRESENT, mBatteryProps.batteryPresent);
- proto.write(BatteryServiceDumpProto.LEVEL, mBatteryProps.batteryLevel);
+ proto.write(BatteryServiceDumpProto.MAX_CHARGING_CURRENT, mHealthInfo.legacy.maxChargingCurrent);
+ proto.write(BatteryServiceDumpProto.MAX_CHARGING_VOLTAGE, mHealthInfo.legacy.maxChargingVoltage);
+ proto.write(BatteryServiceDumpProto.CHARGE_COUNTER, mHealthInfo.legacy.batteryChargeCounter);
+ proto.write(BatteryServiceDumpProto.STATUS, mHealthInfo.legacy.batteryStatus);
+ proto.write(BatteryServiceDumpProto.HEALTH, mHealthInfo.legacy.batteryHealth);
+ proto.write(BatteryServiceDumpProto.IS_PRESENT, mHealthInfo.legacy.batteryPresent);
+ proto.write(BatteryServiceDumpProto.LEVEL, mHealthInfo.legacy.batteryLevel);
proto.write(BatteryServiceDumpProto.SCALE, BATTERY_SCALE);
- proto.write(BatteryServiceDumpProto.VOLTAGE, mBatteryProps.batteryVoltage);
- proto.write(BatteryServiceDumpProto.TEMPERATURE, mBatteryProps.batteryTemperature);
- proto.write(BatteryServiceDumpProto.TECHNOLOGY, mBatteryProps.batteryTechnology);
+ proto.write(BatteryServiceDumpProto.VOLTAGE, mHealthInfo.legacy.batteryVoltage);
+ proto.write(BatteryServiceDumpProto.TEMPERATURE, mHealthInfo.legacy.batteryTemperature);
+ proto.write(BatteryServiceDumpProto.TECHNOLOGY, mHealthInfo.legacy.batteryTechnology);
}
proto.flush();
}
@@ -911,8 +928,8 @@
* Synchronize on BatteryService.
*/
public void updateLightsLocked() {
- final int level = mBatteryProps.batteryLevel;
- final int status = mBatteryProps.batteryStatus;
+ final int level = mHealthInfo.legacy.batteryLevel;
+ final int status = mHealthInfo.legacy.batteryStatus;
if (level < mLowBatteryWarningLevel) {
if (status == BatteryManager.BATTERY_STATUS_CHARGING) {
// Solid red when battery is charging
@@ -985,7 +1002,7 @@
@Override
public int getBatteryLevel() {
synchronized (mLock) {
- return mBatteryProps.batteryLevel;
+ return mHealthInfo.legacy.batteryLevel;
}
}