Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

health package: switch to aidl HealthInfo

Browse Source 
This is the first step of switching to AIDL health HAL. All
usages of HIDL HealthInfo is replaced with AIDL HealthInfo.

Because there's only one definition of HealthInfo in AIDL, all
3 versions of HIDL HealthInfo (1.0, 2.0, 2.1) are converted into
this AIDL HealthInfo.

A new function, Utils.copyV1Battery, is introduced in place of
Utils.copy, to denote that only battery fields in the V1 AIDL
HealthInfo are copied. When we add more battery fields to
HealthInfo in the future, the name V1 suggests that only V1
fields are copied. So we'll only need to change it to copyV2Battery
if we are going to use V2 fields in BatteryService.

Test: boots
Bug: 177269435

Change-Id: I38294bcff7cab72b8a7360a172ad70b22a1fcfe2
This commit is contained in:
Yifan Hong
2021-11-05 15:23:10 -07:00
parent 9d57df9e82
commit 8838bc3d62
8 changed files with 134 additions and 83 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
services/core/Android.bp
View File

@@ -138,9 +138,11 @@ java_library_static {
"android.hardware.boot-V1.1-java",
"android.hardware.boot-V1.2-java",
"android.hardware.broadcastradio-V2.0-java",
"android.hardware.health-V1.0-java",
"android.hardware.health-V2.0-java",
"android.hardware.health-V2.1-java",
"android.hardware.health-V1.0-java", // HIDL
"android.hardware.health-V2.0-java", // HIDL
"android.hardware.health-V2.1-java", // HIDL
"android.hardware.health-V1-java", // AIDL
"android.hardware.health-translate-java",
"android.hardware.light-V1-java",
"android.hardware.tv.cec-V1.1-java",
"android.hardware.weaver-V1.0-java",

151
services/core/java/com/android/server/BatteryService.java
View File

@@ -17,7 +17,7 @@
package com.android.server;
import static com.android.internal.logging.nano.MetricsProto.MetricsEvent;
import static com.android.server.health.Utils.copy;
import static com.android.server.health.Utils.copyV1Battery;
import android.annotation.Nullable;
import android.app.ActivityManager;
@@ -26,7 +26,7 @@ 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.HealthInfo;
import android.hardware.health.V2_1.BatteryCapacityLevel;
import android.metrics.LogMaker;
import android.os.BatteryManager;
@@ -138,7 +138,6 @@ public final class BatteryService extends SystemService {
private HealthInfo mHealthInfo;
private final HealthInfo mLastHealthInfo = new HealthInfo();
private android.hardware.health.V2_1.HealthInfo mHealthInfo2p1;
private boolean mBatteryLevelCritical;
private int mLastBatteryStatus;
private int mLastBatteryHealth;
@@ -354,8 +353,8 @@ public final class BatteryService extends SystemService {
}
private boolean shouldShutdownLocked() {
if (mHealthInfo2p1.batteryCapacityLevel != BatteryCapacityLevel.UNSUPPORTED) {
return (mHealthInfo2p1.batteryCapacityLevel == BatteryCapacityLevel.CRITICAL);
if (mHealthInfo.batteryCapacityLevel != BatteryCapacityLevel.UNSUPPORTED) {
return (mHealthInfo.batteryCapacityLevel == BatteryCapacityLevel.CRITICAL);
}
if (mHealthInfo.batteryLevel > 0) {
return false;
@@ -397,7 +396,7 @@ public final class BatteryService extends SystemService {
// 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) {
if (mHealthInfo.batteryTemperatureTenthsCelsius > mShutdownBatteryTemperature) {
mHandler.post(new Runnable() {
@Override
public void run() {
@@ -414,27 +413,23 @@ public final class BatteryService extends SystemService {
}
}
private void update(android.hardware.health.V2_1.HealthInfo info) {
private void update(android.hardware.health.HealthInfo info) {
traceBegin("HealthInfoUpdate");
Trace.traceCounter(Trace.TRACE_TAG_POWER, "BatteryChargeCounter",
info.legacy.legacy.batteryChargeCounter);
Trace.traceCounter(Trace.TRACE_TAG_POWER, "BatteryCurrent",
info.legacy.legacy.batteryCurrent);
Trace.traceCounter(Trace.TRACE_TAG_POWER, "PlugType",
plugType(info.legacy.legacy));
Trace.traceCounter(Trace.TRACE_TAG_POWER, "BatteryStatus",
info.legacy.legacy.batteryStatus);
Trace.traceCounter(
Trace.TRACE_TAG_POWER, "BatteryChargeCounter", info.batteryChargeCounterUah);
Trace.traceCounter(Trace.TRACE_TAG_POWER, "BatteryCurrent", info.batteryCurrentMicroamps);
Trace.traceCounter(Trace.TRACE_TAG_POWER, "PlugType", plugType(info));
Trace.traceCounter(Trace.TRACE_TAG_POWER, "BatteryStatus", info.batteryStatus);
synchronized (mLock) {
if (!mUpdatesStopped) {
mHealthInfo = info.legacy.legacy;
mHealthInfo2p1 = info;
mHealthInfo = info;
// Process the new values.
processValuesLocked(false);
mLock.notifyAll(); // for any waiters on new info
} else {
copy(mLastHealthInfo, info.legacy.legacy);
copyV1Battery(mLastHealthInfo, info);
}
}
traceEnd();
@@ -470,11 +465,16 @@ public final class BatteryService extends SystemService {
// 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,
mHealthInfo2p1.batteryChargeTimeToFullNowSeconds);
mBatteryStats.setBatteryState(
mHealthInfo.batteryStatus,
mHealthInfo.batteryHealth,
mPlugType,
mHealthInfo.batteryLevel,
mHealthInfo.batteryTemperatureTenthsCelsius,
mHealthInfo.batteryVoltageMillivolts,
mHealthInfo.batteryChargeCounterUah,
mHealthInfo.batteryFullChargeUah,
mHealthInfo.batteryChargeTimeToFullNowSeconds);
} catch (RemoteException e) {
// Should never happen.
}
@@ -482,17 +482,18 @@ public final class BatteryService extends SystemService {
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 (force
|| (mHealthInfo.batteryStatus != mLastBatteryStatus
|| mHealthInfo.batteryHealth != mLastBatteryHealth
|| mHealthInfo.batteryPresent != mLastBatteryPresent
|| mHealthInfo.batteryLevel != mLastBatteryLevel
|| mPlugType != mLastPlugType
|| mHealthInfo.batteryVoltageMillivolts != mLastBatteryVoltage
|| mHealthInfo.batteryTemperatureTenthsCelsius != mLastBatteryTemperature
|| mHealthInfo.maxChargingCurrentMicroamps != mLastMaxChargingCurrent
|| mHealthInfo.maxChargingVoltageMicrovolts != mLastMaxChargingVoltage
|| mHealthInfo.batteryChargeCounterUah != mLastChargeCounter
|| mInvalidCharger != mLastInvalidCharger)) {
if (mPlugType != mLastPlugType) {
if (mLastPlugType == BATTERY_PLUGGED_NONE) {
@@ -549,8 +550,11 @@ public final class BatteryService extends SystemService {
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);
EventLog.writeEvent(
EventLogTags.BATTERY_LEVEL,
mHealthInfo.batteryLevel,
mHealthInfo.batteryVoltageMillivolts,
mHealthInfo.batteryTemperatureTenthsCelsius);
}
if (mBatteryLevelCritical && !mLastBatteryLevelCritical &&
mPlugType == BATTERY_PLUGGED_NONE) {
@@ -656,11 +660,11 @@ public final class BatteryService extends SystemService {
mLastBatteryPresent = mHealthInfo.batteryPresent;
mLastBatteryLevel = mHealthInfo.batteryLevel;
mLastPlugType = mPlugType;
mLastBatteryVoltage = mHealthInfo.batteryVoltage;
mLastBatteryTemperature = mHealthInfo.batteryTemperature;
mLastMaxChargingCurrent = mHealthInfo.maxChargingCurrent;
mLastMaxChargingVoltage = mHealthInfo.maxChargingVoltage;
mLastChargeCounter = mHealthInfo.batteryChargeCounter;
mLastBatteryVoltage = mHealthInfo.batteryVoltageMillivolts;
mLastBatteryTemperature = mHealthInfo.batteryTemperatureTenthsCelsius;
mLastMaxChargingCurrent = mHealthInfo.maxChargingCurrentMicroamps;
mLastMaxChargingVoltage = mHealthInfo.maxChargingVoltageMicrovolts;
mLastChargeCounter = mHealthInfo.batteryChargeCounterUah;
mLastBatteryLevelCritical = mBatteryLevelCritical;
mLastInvalidCharger = mInvalidCharger;
}
@@ -683,13 +687,17 @@ public final class BatteryService extends SystemService {
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_VOLTAGE, mHealthInfo.batteryVoltageMillivolts);
intent.putExtra(
BatteryManager.EXTRA_TEMPERATURE, mHealthInfo.batteryTemperatureTenthsCelsius);
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);
intent.putExtra(
BatteryManager.EXTRA_MAX_CHARGING_CURRENT, mHealthInfo.maxChargingCurrentMicroamps);
intent.putExtra(
BatteryManager.EXTRA_MAX_CHARGING_VOLTAGE,
mHealthInfo.maxChargingVoltageMicrovolts);
intent.putExtra(BatteryManager.EXTRA_CHARGE_COUNTER, mHealthInfo.batteryChargeCounterUah);
if (DEBUG) {
Slog.d(TAG, "Sending ACTION_BATTERY_CHANGED. scale:" + BATTERY_SCALE
+ ", info:" + mHealthInfo.toString());
@@ -709,9 +717,9 @@ public final class BatteryService extends SystemService {
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.putInt(BatteryManager.EXTRA_TEMPERATURE, mHealthInfo.batteryTemperature);
event.putInt(BatteryManager.EXTRA_CHARGE_COUNTER, mHealthInfo.batteryChargeCounter);
event.putInt(BatteryManager.EXTRA_VOLTAGE, mHealthInfo.batteryVoltageMillivolts);
event.putInt(BatteryManager.EXTRA_TEMPERATURE, mHealthInfo.batteryTemperatureTenthsCelsius);
event.putInt(BatteryManager.EXTRA_CHARGE_COUNTER, mHealthInfo.batteryChargeCounterUah);
event.putLong(BatteryManager.EXTRA_EVENT_TIMESTAMP, now);
boolean queueWasEmpty = mBatteryLevelsEventQueue.isEmpty();
@@ -903,7 +911,7 @@ public final class BatteryService extends SystemService {
}
try {
if (!mUpdatesStopped) {
copy(mLastHealthInfo, mHealthInfo);
copyV1Battery(mLastHealthInfo, mHealthInfo);
}
boolean update = true;
switch (key) {
@@ -926,10 +934,10 @@ public final class BatteryService extends SystemService {
mHealthInfo.batteryLevel = Integer.parseInt(value);
break;
case "counter":
mHealthInfo.batteryChargeCounter = Integer.parseInt(value);
mHealthInfo.batteryChargeCounterUah = Integer.parseInt(value);
break;
case "temp":
mHealthInfo.batteryTemperature = Integer.parseInt(value);
mHealthInfo.batteryTemperatureTenthsCelsius = Integer.parseInt(value);
break;
case "invalid":
mInvalidCharger = Integer.parseInt(value);
@@ -973,7 +981,7 @@ public final class BatteryService extends SystemService {
private void setChargerAcOnline(boolean online, boolean forceUpdate) {
if (!mUpdatesStopped) {
copy(mLastHealthInfo, mHealthInfo);
copyV1Battery(mLastHealthInfo, mHealthInfo);
}
mHealthInfo.chargerAcOnline = online;
mUpdatesStopped = true;
@@ -982,7 +990,7 @@ public final class BatteryService extends SystemService {
private void setBatteryLevel(int level, boolean forceUpdate) {
if (!mUpdatesStopped) {
copy(mLastHealthInfo, mHealthInfo);
copyV1Battery(mLastHealthInfo, mHealthInfo);
}
mHealthInfo.batteryLevel = level;
mUpdatesStopped = true;
@@ -991,7 +999,7 @@ public final class BatteryService extends SystemService {
private void unplugBattery(boolean forceUpdate, PrintWriter pw) {
if (!mUpdatesStopped) {
copy(mLastHealthInfo, mHealthInfo);
copyV1Battery(mLastHealthInfo, mHealthInfo);
}
mHealthInfo.chargerAcOnline = false;
mHealthInfo.chargerUsbOnline = false;
@@ -1003,7 +1011,7 @@ public final class BatteryService extends SystemService {
private void resetBattery(boolean forceUpdate, @Nullable PrintWriter pw) {
if (mUpdatesStopped) {
mUpdatesStopped = false;
copy(mHealthInfo, mLastHealthInfo);
copyV1Battery(mHealthInfo, mLastHealthInfo);
Binder.withCleanCallingIdentity(() -> processValuesLocked(forceUpdate, pw));
}
if (mBatteryInputSuspended) {
@@ -1038,16 +1046,16 @@ public final class BatteryService extends SystemService {
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(" Max charging current: " + mHealthInfo.maxChargingCurrentMicroamps);
pw.println(" Max charging voltage: " + mHealthInfo.maxChargingVoltageMicrovolts);
pw.println(" Charge counter: " + mHealthInfo.batteryChargeCounterUah);
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(" voltage: " + mHealthInfo.batteryVoltageMillivolts);
pw.println(" temperature: " + mHealthInfo.batteryTemperatureTenthsCelsius);
pw.println(" technology: " + mHealthInfo.batteryTechnology);
} else {
Shell shell = new Shell();
@@ -1070,16 +1078,23 @@ public final class BatteryService extends SystemService {
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.MAX_CHARGING_CURRENT,
mHealthInfo.maxChargingCurrentMicroamps);
proto.write(
BatteryServiceDumpProto.MAX_CHARGING_VOLTAGE,
mHealthInfo.maxChargingVoltageMicrovolts);
proto.write(
BatteryServiceDumpProto.CHARGE_COUNTER, mHealthInfo.batteryChargeCounterUah);
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.VOLTAGE, mHealthInfo.batteryVoltageMillivolts);
proto.write(
BatteryServiceDumpProto.TEMPERATURE,
mHealthInfo.batteryTemperatureTenthsCelsius);
proto.write(BatteryServiceDumpProto.TECHNOLOGY, mHealthInfo.batteryTechnology);
}
proto.flush();
@@ -1207,14 +1222,14 @@ public final class BatteryService extends SystemService {
@Override
public int getBatteryChargeCounter() {
synchronized (mLock) {
return mHealthInfo.batteryChargeCounter;
return mHealthInfo.batteryChargeCounterUah;
}
}
@Override
public int getBatteryFullCharge() {
synchronized (mLock) {
return mHealthInfo.batteryFullCharge;
return mHealthInfo.batteryFullChargeUah;
}
}

6
services/core/java/com/android/server/health/HealthHalCallbackHidl.java
View File

@@ -16,6 +16,8 @@
package com.android.server.health;
import static android.hardware.health.Translate.h2aTranslate;
import android.annotation.NonNull;
import android.hardware.health.V2_0.IHealth;
import android.hardware.health.V2_0.Result;
@@ -64,12 +66,12 @@ class HealthHalCallbackHidl extends IHealthInfoCallback.Stub
propsLatest.batteryChargeTimeToFullNowSeconds =
Constants.BATTERY_CHARGE_TIME_TO_FULL_NOW_SECONDS_UNSUPPORTED;
mCallback.update(propsLatest);
mCallback.update(h2aTranslate(propsLatest));
}
@Override
public void healthInfoChanged_2_1(android.hardware.health.V2_1.HealthInfo props) {
mCallback.update(props);
mCallback.update(h2aTranslate(props));
}
// on new service registered

3
services/core/java/com/android/server/health/HealthInfoCallback.java
View File

@@ -27,6 +27,5 @@ public interface HealthInfoCallback {
*
* @param props the new health info.
*/
// TODO(b/177269435): AIDL
void update(android.hardware.health.V2_1.HealthInfo props);
void update(android.hardware.health.HealthInfo props);
}

3
services/core/java/com/android/server/health/HealthServiceWrapper.java
View File

@@ -68,8 +68,7 @@ public abstract class HealthServiceWrapper {
* service-specific error when calling {@code getHealthInfo}, e.g. it is unsupported.
* @throws RemoteException for any transaction-level errors
*/
// TODO(b/177269435): AIDL
public abstract android.hardware.health.V1_0.HealthInfo getHealthInfo() throws RemoteException;
public abstract android.hardware.health.HealthInfo getHealthInfo() throws RemoteException;
/**
* Create a new HealthServiceWrapper instance.

6
services/core/java/com/android/server/health/HealthServiceWrapperHidl.java
View File

@@ -16,9 +16,11 @@
package com.android.server.health;
import static android.hardware.health.Translate.h2aTranslate;
import android.annotation.NonNull;
import android.annotation.Nullable;
import android.hardware.health.V1_0.HealthInfo;
import android.hardware.health.HealthInfo;
import android.hardware.health.V2_0.IHealth;
import android.hardware.health.V2_0.Result;
import android.hidl.manager.V1_0.IServiceManager;
@@ -155,7 +157,7 @@ final class HealthServiceWrapperHidl extends HealthServiceWrapper {
service.getHealthInfo(
(result, value) -> {
if (result == Result.SUCCESS) {
ret.value = value.legacy;
ret.value = h2aTranslate(value.legacy);
}
});
return ret.value;

32
services/core/java/com/android/server/health/Utils.java
View File

@@ -50,4 +50,36 @@ public class Utils {
dst.batteryChargeCounter = src.batteryChargeCounter;
dst.batteryTechnology = src.batteryTechnology;
}
/**
* Copy battery fields of {@link android.hardware.health.HealthInfo} V1. This excludes
* non-battery fields like {@link android.hardware.health.HealthInfo#diskStats diskStats} and
* {@link android.hardware.health.HealthInfo#storageInfos storageInfos}
*
* @param dst destination
* @param src source
*/
public static void copyV1Battery(
android.hardware.health.HealthInfo dst, android.hardware.health.HealthInfo src) {
dst.chargerAcOnline = src.chargerAcOnline;
dst.chargerUsbOnline = src.chargerUsbOnline;
dst.chargerWirelessOnline = src.chargerWirelessOnline;
dst.maxChargingCurrentMicroamps = src.maxChargingCurrentMicroamps;
dst.maxChargingVoltageMicrovolts = src.maxChargingVoltageMicrovolts;
dst.batteryStatus = src.batteryStatus;
dst.batteryHealth = src.batteryHealth;
dst.batteryPresent = src.batteryPresent;
dst.batteryLevel = src.batteryLevel;
dst.batteryVoltageMillivolts = src.batteryVoltageMillivolts;
dst.batteryTemperatureTenthsCelsius = src.batteryTemperatureTenthsCelsius;
dst.batteryCurrentMicroamps = src.batteryCurrentMicroamps;
dst.batteryCycleCount = src.batteryCycleCount;
dst.batteryFullChargeUah = src.batteryFullChargeUah;
dst.batteryChargeCounterUah = src.batteryChargeCounterUah;
dst.batteryTechnology = src.batteryTechnology;
dst.batteryCurrentAverageMicroamps = src.batteryCurrentAverageMicroamps;
dst.batteryCapacityLevel = src.batteryCapacityLevel;
dst.batteryChargeTimeToFullNowSeconds = src.batteryChargeTimeToFullNowSeconds;
dst.batteryFullChargeDesignCapacityUah = src.batteryFullChargeDesignCapacityUah;
}
}

8
services/core/java/com/android/server/stats/pull/StatsPullAtomService.java
View File

@@ -3977,7 +3977,7 @@ public class StatsPullAtomService extends SystemService {
if (mHealthService == null) {
return StatsManager.PULL_SKIP;
}
android.hardware.health.V1_0.HealthInfo healthInfo;
android.hardware.health.HealthInfo healthInfo;
try {
healthInfo = mHealthService.getHealthInfo();
} catch (RemoteException | IllegalStateException e) {
@@ -3993,13 +3993,13 @@ public class StatsPullAtomService extends SystemService {
pulledValue = healthInfo.batteryLevel;
break;
case FrameworkStatsLog.REMAINING_BATTERY_CAPACITY:
pulledValue = healthInfo.batteryChargeCounter;
pulledValue = healthInfo.batteryChargeCounterUah;
break;
case FrameworkStatsLog.FULL_BATTERY_CAPACITY:
pulledValue = healthInfo.batteryFullCharge;
pulledValue = healthInfo.batteryFullChargeUah;
break;
case FrameworkStatsLog.BATTERY_VOLTAGE:
pulledValue = healthInfo.batteryVoltage;
pulledValue = healthInfo.batteryVoltageMillivolts;
break;
case FrameworkStatsLog.BATTERY_CYCLE_COUNT:
pulledValue = healthInfo.batteryCycleCount;