diff --git a/healthd/Android.bp b/healthd/Android.bp index 76b6ad0ae..9b5d05fd1 100644 --- a/healthd/Android.bp +++ b/healthd/Android.bp @@ -76,7 +76,7 @@ cc_library_static { name: "libbatterymonitor", defaults: ["libbatterymonitor_defaults"], static_libs: [ - "android.hardware.health-V1-ndk", + "android.hardware.health-V2-ndk", ], whole_static_libs: [ // Need to translate HIDL to AIDL to support legacy APIs in @@ -202,12 +202,12 @@ cc_library_static { defaults: ["libhealthd_charger_ui_defaults"], static_libs: [ - "android.hardware.health-V1-ndk", + "android.hardware.health-V2-ndk", "android.hardware.health-translate-ndk", ], export_static_lib_headers: [ - "android.hardware.health-V1-ndk", + "android.hardware.health-V2-ndk", ], } @@ -279,7 +279,7 @@ cc_defaults { static_libs: [ // common "android.hardware.health@1.0-convert", - "android.hardware.health-V1-ndk", + "android.hardware.health-V2-ndk", "libbatterymonitor", "libcharger_sysprop", "libhealthd_charger_nops", diff --git a/healthd/BatteryMonitor.cpp b/healthd/BatteryMonitor.cpp index a7571a260..4ea452a10 100644 --- a/healthd/BatteryMonitor.cpp +++ b/healthd/BatteryMonitor.cpp @@ -55,7 +55,10 @@ using HealthInfo_1_0 = android::hardware::health::V1_0::HealthInfo; using HealthInfo_2_0 = android::hardware::health::V2_0::HealthInfo; using HealthInfo_2_1 = android::hardware::health::V2_1::HealthInfo; using aidl::android::hardware::health::BatteryCapacityLevel; +using aidl::android::hardware::health::BatteryChargingPolicy; +using aidl::android::hardware::health::BatteryChargingState; using aidl::android::hardware::health::BatteryHealth; +using aidl::android::hardware::health::BatteryHealthData; using aidl::android::hardware::health::BatteryStatus; using aidl::android::hardware::health::HealthInfo; @@ -227,6 +230,37 @@ BatteryHealth getBatteryHealth(const char* status) { return *ret; } +BatteryChargingPolicy getBatteryChargingPolicy(const char* chargingPolicy) { + static SysfsStringEnumMap batteryChargingPolicyMap[] = { + {"0", BatteryChargingPolicy::INVALID}, {"1", BatteryChargingPolicy::DEFAULT}, + {"2", BatteryChargingPolicy::LONG_LIFE}, {"3", BatteryChargingPolicy::ADAPTIVE}, + {NULL, BatteryChargingPolicy::DEFAULT}, + }; + + auto ret = mapSysfsString(chargingPolicy, batteryChargingPolicyMap); + if (!ret) { + *ret = BatteryChargingPolicy::DEFAULT; + } + + return *ret; +} + +BatteryChargingState getBatteryChargingState(const char* chargingState) { + static SysfsStringEnumMap batteryChargingStateMap[] = { + {"0", BatteryChargingState::INVALID}, {"1", BatteryChargingState::NORMAL}, + {"2", BatteryChargingState::TOO_COLD}, {"3", BatteryChargingState::TOO_HOT}, + {"4", BatteryChargingState::LONG_LIFE}, {"5", BatteryChargingState::ADAPTIVE}, + {NULL, BatteryChargingState::NORMAL}, + }; + + auto ret = mapSysfsString(chargingState, batteryChargingStateMap); + if (!ret) { + *ret = BatteryChargingState::NORMAL; + } + + return *ret; +} + static int readFromFile(const String8& path, std::string* buf) { buf->clear(); if (android::base::ReadFileToString(path.c_str(), buf)) { @@ -235,6 +269,10 @@ static int readFromFile(const String8& path, std::string* buf) { return buf->length(); } +static bool writeToFile(const String8& path, int32_t in_value) { + return android::base::WriteStringToFile(std::to_string(in_value), path.c_str()); +} + static BatteryMonitor::PowerSupplyType readPowerSupplyType(const String8& path) { static SysfsStringEnumMap supplyTypeMap[] = { {"Unknown", BatteryMonitor::ANDROID_POWER_SUPPLY_TYPE_UNKNOWN}, @@ -336,6 +374,17 @@ void BatteryMonitor::updateValues(void) { mHealthInfo->batteryFullChargeDesignCapacityUah = getIntField(mHealthdConfig->batteryFullChargeDesignCapacityUahPath); + if (!mHealthdConfig->batteryStateOfHealthPath.isEmpty()) + mHealthInfo->batteryStateOfHealth = getIntField(mHealthdConfig->batteryStateOfHealthPath); + + if (!mHealthdConfig->batteryManufacturingDatePath.isEmpty()) + mHealthInfo->batteryHealthData->batteryManufacturingDateSeconds = + getIntField(mHealthdConfig->batteryManufacturingDatePath); + + if (!mHealthdConfig->batteryFirstUsageDatePath.isEmpty()) + mHealthInfo->batteryHealthData->batteryFirstUsageSeconds = + getIntField(mHealthdConfig->batteryFirstUsageDatePath); + mHealthInfo->batteryTemperatureTenthsCelsius = mBatteryFixedTemperature ? mBatteryFixedTemperature : getIntField(mHealthdConfig->batteryTemperaturePath); @@ -354,6 +403,12 @@ void BatteryMonitor::updateValues(void) { if (readFromFile(mHealthdConfig->batteryTechnologyPath, &buf) > 0) mHealthInfo->batteryTechnology = String8(buf.c_str()); + if (readFromFile(mHealthdConfig->chargingPolicyPath, &buf) > 0) + mHealthInfo->chargingPolicy = getBatteryChargingPolicy(buf.c_str()); + + if (readFromFile(mHealthdConfig->chargingStatePath, &buf) > 0) + mHealthInfo->chargingState = getBatteryChargingState(buf.c_str()); + double MaxPower = 0; for (size_t i = 0; i < mChargerNames.size(); i++) { @@ -476,6 +531,43 @@ int BatteryMonitor::getChargeStatus() { return static_cast(result); } +status_t BatteryMonitor::setChargingPolicy(int value) { + status_t ret = NAME_NOT_FOUND; + bool result; + if (!mHealthdConfig->chargingPolicyPath.isEmpty()) { + result = writeToFile(mHealthdConfig->chargingPolicyPath, value); + if (!result) { + KLOG_WARNING(LOG_TAG, "setChargingPolicy fail\n"); + ret = BAD_VALUE; + } else { + ret = OK; + } + } + return ret; +} + +int BatteryMonitor::getChargingPolicy() { + BatteryChargingPolicy result = BatteryChargingPolicy::DEFAULT; + if (!mHealthdConfig->chargingPolicyPath.isEmpty()) { + std::string buf; + if (readFromFile(mHealthdConfig->chargingPolicyPath, &buf) > 0) + result = getBatteryChargingPolicy(buf.c_str()); + } + return static_cast(result); +} + +int BatteryMonitor::getBatteryHealthData(int id) { + if (id == BATTERY_PROP_MANUFACTURING_DATE) { + if (!mHealthdConfig->batteryManufacturingDatePath.isEmpty()) + return getIntField(mHealthdConfig->batteryManufacturingDatePath); + } + if (id == BATTERY_PROP_FIRST_USAGE_DATE) { + if (!mHealthdConfig->batteryFirstUsageDatePath.isEmpty()) + return getIntField(mHealthdConfig->batteryFirstUsageDatePath); + } + return 0; +} + status_t BatteryMonitor::getProperty(int id, struct BatteryProperty *val) { status_t ret = BAD_VALUE; std::string buf; @@ -536,6 +628,21 @@ status_t BatteryMonitor::getProperty(int id, struct BatteryProperty *val) { ret = OK; break; + case BATTERY_PROP_CHARGING_POLICY: + val->valueInt64 = getChargingPolicy(); + ret = OK; + break; + + case BATTERY_PROP_MANUFACTURING_DATE: + val->valueInt64 = getBatteryHealthData(BATTERY_PROP_MANUFACTURING_DATE); + ret = OK; + break; + + case BATTERY_PROP_FIRST_USAGE_DATE: + val->valueInt64 = getBatteryHealthData(BATTERY_PROP_FIRST_USAGE_DATE); + ret = OK; + break; + default: break; } @@ -758,6 +865,44 @@ void BatteryMonitor::init(struct healthd_config *hc) { mHealthdConfig->batteryTechnologyPath = path; } + if (mHealthdConfig->batteryStateOfHealthPath.isEmpty()) { + path.clear(); + path.appendFormat("%s/%s/state_of_health", POWER_SUPPLY_SYSFS_PATH, name); + if (access(path, R_OK) == 0) { + mHealthdConfig->batteryStateOfHealthPath = path; + } else { + path.clear(); + path.appendFormat("%s/%s/health_index", POWER_SUPPLY_SYSFS_PATH, name); + if (access(path, R_OK) == 0) + mHealthdConfig->batteryStateOfHealthPath = path; + } + } + + if (mHealthdConfig->batteryManufacturingDatePath.isEmpty()) { + path.clear(); + path.appendFormat("%s/%s/manufacturing_date", POWER_SUPPLY_SYSFS_PATH, name); + if (access(path, R_OK) == 0) + mHealthdConfig->batteryManufacturingDatePath = path; + } + + if (mHealthdConfig->batteryFirstUsageDatePath.isEmpty()) { + path.clear(); + path.appendFormat("%s/%s/first_usage_date", POWER_SUPPLY_SYSFS_PATH, name); + if (access(path, R_OK) == 0) mHealthdConfig->batteryFirstUsageDatePath = path; + } + + if (mHealthdConfig->chargingStatePath.isEmpty()) { + path.clear(); + path.appendFormat("%s/%s/charging_state", POWER_SUPPLY_SYSFS_PATH, name); + if (access(path, R_OK) == 0) mHealthdConfig->chargingStatePath = path; + } + + if (mHealthdConfig->chargingPolicyPath.isEmpty()) { + path.clear(); + path.appendFormat("%s/%s/charging_policy", POWER_SUPPLY_SYSFS_PATH, name); + if (access(path, R_OK) == 0) mHealthdConfig->chargingPolicyPath = path; + } + break; case ANDROID_POWER_SUPPLY_TYPE_UNKNOWN: @@ -810,6 +955,16 @@ void BatteryMonitor::init(struct healthd_config *hc) { KLOG_WARNING(LOG_TAG, "batteryChargeTimeToFullNowPath. not found\n"); if (mHealthdConfig->batteryFullChargeDesignCapacityUahPath.isEmpty()) KLOG_WARNING(LOG_TAG, "batteryFullChargeDesignCapacityUahPath. not found\n"); + if (mHealthdConfig->batteryStateOfHealthPath.isEmpty()) + KLOG_WARNING(LOG_TAG, "batteryStateOfHealthPath not found\n"); + if (mHealthdConfig->batteryManufacturingDatePath.isEmpty()) + KLOG_WARNING(LOG_TAG, "batteryManufacturingDatePath not found\n"); + if (mHealthdConfig->batteryFirstUsageDatePath.isEmpty()) + KLOG_WARNING(LOG_TAG, "batteryFirstUsageDatePath not found\n"); + if (mHealthdConfig->chargingStatePath.isEmpty()) + KLOG_WARNING(LOG_TAG, "chargingStatePath not found\n"); + if (mHealthdConfig->chargingPolicyPath.isEmpty()) + KLOG_WARNING(LOG_TAG, "chargingPolicyPath not found\n"); } if (property_get("ro.boot.fake_battery", pval, NULL) > 0 diff --git a/healthd/include/healthd/BatteryMonitor.h b/healthd/include/healthd/BatteryMonitor.h index 8cbf5ead6..4af2a87f7 100644 --- a/healthd/include/healthd/BatteryMonitor.h +++ b/healthd/include/healthd/BatteryMonitor.h @@ -72,6 +72,10 @@ class BatteryMonitor { void logValues(void); bool isChargerOnline(); + int setChargingPolicy(int value); + int getChargingPolicy(); + int getBatteryHealthData(int id); + static void logValues(const android::hardware::health::V2_1::HealthInfo& health_info, const struct healthd_config& healthd_config); diff --git a/healthd/include/healthd/healthd.h b/healthd/include/healthd/healthd.h index 706c3328e..e1c357ccc 100644 --- a/healthd/include/healthd/healthd.h +++ b/healthd/include/healthd/healthd.h @@ -72,6 +72,11 @@ struct healthd_config { android::String8 batteryCapacityLevelPath; android::String8 batteryChargeTimeToFullNowPath; android::String8 batteryFullChargeDesignCapacityUahPath; + android::String8 batteryStateOfHealthPath; + android::String8 batteryManufacturingDatePath; + android::String8 batteryFirstUsageDatePath; + android::String8 chargingStatePath; + android::String8 chargingPolicyPath; int (*energyCounter)(int64_t *); int boot_min_cap;