blob: 37662eacf32493e605938362c2f40a1cec286fea [file] [log] [blame]
/*
* Copyright (C) 2021 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.
*/
#include "health-impl/Health.h"
#include <android-base/file.h>
#include <android-base/logging.h>
#include <android/binder_manager.h>
#include <android/binder_process.h>
#include <android/hardware/health/translate-ndk.h>
#include <health/utils.h>
#include "LinkedCallback.h"
#include "health-convert.h"
using std::string_literals::operator""s;
namespace aidl::android::hardware::health {
namespace {
// Wrap LinkedCallback::OnCallbackDied() into a void(void*).
void OnCallbackDiedWrapped(void* cookie) {
LinkedCallback* linked = reinterpret_cast<LinkedCallback*>(cookie);
linked->OnCallbackDied();
}
// Delete the owned cookie.
void onCallbackUnlinked(void* cookie) {
LinkedCallback* linked = reinterpret_cast<LinkedCallback*>(cookie);
delete linked;
}
} // namespace
/*
// If you need to call healthd_board_init, construct the Health instance with
// the healthd_config after calling healthd_board_init:
class MyHealth : public Health {
protected:
MyHealth() : Health(CreateConfig()) {}
private:
static std::unique_ptr<healthd_config> CreateConfig() {
auto config = std::make_unique<healthd_config>();
::android::hardware::health::InitHealthdConfig(config.get());
healthd_board_init(config.get());
return std::move(config);
}
};
*/
Health::Health(std::string_view instance_name, std::unique_ptr<struct healthd_config>&& config)
: instance_name_(instance_name),
healthd_config_(std::move(config)),
death_recipient_(AIBinder_DeathRecipient_new(&OnCallbackDiedWrapped)) {
AIBinder_DeathRecipient_setOnUnlinked(death_recipient_.get(), onCallbackUnlinked);
battery_monitor_.init(healthd_config_.get());
}
Health::~Health() {}
static inline ndk::ScopedAStatus TranslateStatus(::android::status_t err) {
switch (err) {
case ::android::OK:
return ndk::ScopedAStatus::ok();
case ::android::NAME_NOT_FOUND:
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
default:
return ndk::ScopedAStatus::fromServiceSpecificErrorWithMessage(
IHealth::STATUS_UNKNOWN, ::android::statusToString(err).c_str());
}
}
//
// Getters.
//
template <typename T>
static ndk::ScopedAStatus GetProperty(::android::BatteryMonitor* monitor, int id, T defaultValue,
T* out) {
*out = defaultValue;
struct ::android::BatteryProperty prop;
::android::status_t err = monitor->getProperty(static_cast<int>(id), &prop);
if (err == ::android::OK) {
*out = static_cast<T>(prop.valueInt64);
} else {
LOG(DEBUG) << "getProperty(" << id << ")"
<< " fails: (" << err << ") " << ::android::statusToString(err);
}
return TranslateStatus(err);
}
ndk::ScopedAStatus Health::getChargeCounterUah(int32_t* out) {
return GetProperty<int32_t>(&battery_monitor_, ::android::BATTERY_PROP_CHARGE_COUNTER, 0, out);
}
ndk::ScopedAStatus Health::getCurrentNowMicroamps(int32_t* out) {
return GetProperty<int32_t>(&battery_monitor_, ::android::BATTERY_PROP_CURRENT_NOW, 0, out);
}
ndk::ScopedAStatus Health::getCurrentAverageMicroamps(int32_t* out) {
return GetProperty<int32_t>(&battery_monitor_, ::android::BATTERY_PROP_CURRENT_AVG, 0, out);
}
ndk::ScopedAStatus Health::getCapacity(int32_t* out) {
return GetProperty<int32_t>(&battery_monitor_, ::android::BATTERY_PROP_CAPACITY, 0, out);
}
ndk::ScopedAStatus Health::getEnergyCounterNwh(int64_t* out) {
return GetProperty<int64_t>(&battery_monitor_, ::android::BATTERY_PROP_ENERGY_COUNTER, 0, out);
}
ndk::ScopedAStatus Health::getChargeStatus(BatteryStatus* out) {
return GetProperty(&battery_monitor_, ::android::BATTERY_PROP_BATTERY_STATUS,
BatteryStatus::UNKNOWN, out);
}
ndk::ScopedAStatus Health::setChargingPolicy(BatteryChargingPolicy in_value) {
::android::status_t err = battery_monitor_.setChargingPolicy(static_cast<int>(in_value));
switch (err) {
case ::android::OK:
return ndk::ScopedAStatus::ok();
case ::android::NAME_NOT_FOUND:
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
case ::android::BAD_VALUE:
return ndk::ScopedAStatus::fromStatus(::android::INVALID_OPERATION);
default:
return ndk::ScopedAStatus::fromServiceSpecificErrorWithMessage(
IHealth::STATUS_UNKNOWN, ::android::statusToString(err).c_str());
}
}
ndk::ScopedAStatus Health::getChargingPolicy(BatteryChargingPolicy* out) {
return GetProperty(&battery_monitor_, ::android::BATTERY_PROP_CHARGING_POLICY,
BatteryChargingPolicy::DEFAULT, out);
}
ndk::ScopedAStatus Health::getBatteryHealthData(BatteryHealthData* out) {
if (auto res =
GetProperty<int64_t>(&battery_monitor_, ::android::BATTERY_PROP_MANUFACTURING_DATE,
0, &out->batteryManufacturingDateSeconds);
!res.isOk()) {
LOG(WARNING) << "Cannot get Manufacturing_date: " << res.getDescription();
}
if (auto res = GetProperty<int64_t>(&battery_monitor_, ::android::BATTERY_PROP_FIRST_USAGE_DATE,
0, &out->batteryFirstUsageSeconds);
!res.isOk()) {
LOG(WARNING) << "Cannot get First_usage_date: " << res.getDescription();
}
if (auto res = GetProperty<int64_t>(&battery_monitor_, ::android::BATTERY_PROP_STATE_OF_HEALTH,
0, &out->batteryStateOfHealth);
!res.isOk()) {
LOG(WARNING) << "Cannot get Battery_state_of_health: " << res.getDescription();
}
if (auto res = battery_monitor_.getSerialNumber(&out->batterySerialNumber);
res != ::android::OK) {
LOG(WARNING) << "Cannot get Battery_serial_number: "
<< TranslateStatus(res).getDescription();
}
int64_t part_status = static_cast<int64_t>(BatteryPartStatus::UNSUPPORTED);
if (auto res = GetProperty<int64_t>(&battery_monitor_, ::android::BATTERY_PROP_PART_STATUS,
static_cast<int64_t>(BatteryPartStatus::UNSUPPORTED),
&part_status);
!res.isOk()) {
LOG(WARNING) << "Cannot get Battery_part_status: " << res.getDescription();
}
out->batteryPartStatus = static_cast<BatteryPartStatus>(part_status);
return ndk::ScopedAStatus::ok();
}
ndk::ScopedAStatus Health::getDiskStats(std::vector<DiskStats>*) {
// This implementation does not support DiskStats. An implementation may extend this
// class and override this function to support disk stats.
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}
ndk::ScopedAStatus Health::getStorageInfo(std::vector<StorageInfo>*) {
// This implementation does not support StorageInfo. An implementation may extend this
// class and override this function to support storage info.
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}
ndk::ScopedAStatus Health::getHealthInfo(HealthInfo* out) {
battery_monitor_.updateValues();
*out = battery_monitor_.getHealthInfo();
// Fill in storage infos; these aren't retrieved by BatteryMonitor.
if (auto res = getStorageInfo(&out->storageInfos); !res.isOk()) {
if (res.getServiceSpecificError() == 0 &&
res.getExceptionCode() != EX_UNSUPPORTED_OPERATION) {
return ndk::ScopedAStatus::fromServiceSpecificErrorWithMessage(
IHealth::STATUS_UNKNOWN,
("getStorageInfo fails: " + res.getDescription()).c_str());
}
LOG(DEBUG) << "getHealthInfo: getStorageInfo fails with service-specific error, clearing: "
<< res.getDescription();
out->storageInfos = {};
}
if (auto res = getDiskStats(&out->diskStats); !res.isOk()) {
if (res.getServiceSpecificError() == 0 &&
res.getExceptionCode() != EX_UNSUPPORTED_OPERATION) {
return ndk::ScopedAStatus::fromServiceSpecificErrorWithMessage(
IHealth::STATUS_UNKNOWN,
("getDiskStats fails: " + res.getDescription()).c_str());
}
LOG(DEBUG) << "getHealthInfo: getDiskStats fails with service-specific error, clearing: "
<< res.getDescription();
out->diskStats = {};
}
// A subclass may want to update health info struct before returning it.
UpdateHealthInfo(out);
return ndk::ScopedAStatus::ok();
}
binder_status_t Health::dump(int fd, const char**, uint32_t) {
battery_monitor_.dumpState(fd);
::android::base::WriteStringToFd("\ngetHealthInfo -> ", fd);
HealthInfo health_info;
auto res = getHealthInfo(&health_info);
if (res.isOk()) {
::android::base::WriteStringToFd(health_info.toString(), fd);
} else {
::android::base::WriteStringToFd(res.getDescription(), fd);
}
::android::base::WriteStringToFd("\n", fd);
fsync(fd);
return STATUS_OK;
}
std::optional<bool> Health::ShouldKeepScreenOn() {
if (!healthd_config_->screen_on) {
return std::nullopt;
}
HealthInfo health_info;
auto res = getHealthInfo(&health_info);
if (!res.isOk()) {
return std::nullopt;
}
::android::BatteryProperties props = {};
convert(health_info, &props);
return healthd_config_->screen_on(&props);
}
//
// Subclass helpers / overrides
//
void Health::UpdateHealthInfo(HealthInfo* /* health_info */) {
/*
// Sample code for a subclass to implement this:
// If you need to modify values (e.g. batteryChargeTimeToFullNowSeconds), do it here.
health_info->batteryChargeTimeToFullNowSeconds = calculate_charge_time_seconds();
// If you need to call healthd_board_battery_update, modify its signature
// and implementation to operate on HealthInfo directly, then call:
healthd_board_battery_update(health_info);
*/
}
//
// Methods that handle callbacks.
//
ndk::ScopedAStatus Health::registerCallback(const std::shared_ptr<IHealthInfoCallback>& callback) {
if (callback == nullptr) {
// For now, this shouldn't happen because argument is not nullable.
return ndk::ScopedAStatus::fromExceptionCode(EX_NULL_POINTER);
}
{
std::lock_guard<decltype(callbacks_lock_)> lock(callbacks_lock_);
auto linked_callback_result = LinkedCallback::Make(ref<Health>(), callback);
if (!linked_callback_result.ok()) {
return ndk::ScopedAStatus::fromStatus(-linked_callback_result.error().code());
}
callbacks_[*linked_callback_result] = callback;
// unlock
}
HealthInfo health_info;
if (auto res = getHealthInfo(&health_info); !res.isOk()) {
LOG(WARNING) << "Cannot call getHealthInfo: " << res.getDescription();
// No health info to send, so return early.
return ndk::ScopedAStatus::ok();
}
auto res = callback->healthInfoChanged(health_info);
if (!res.isOk()) {
LOG(DEBUG) << "Cannot call healthInfoChanged:" << res.getDescription()
<< ". Do nothing here if callback is dead as it will be cleaned up later.";
}
return ndk::ScopedAStatus::ok();
}
ndk::ScopedAStatus Health::unregisterCallback(
const std::shared_ptr<IHealthInfoCallback>& callback) {
if (callback == nullptr) {
// For now, this shouldn't happen because argument is not nullable.
return ndk::ScopedAStatus::fromExceptionCode(EX_NULL_POINTER);
}
std::lock_guard<decltype(callbacks_lock_)> lock(callbacks_lock_);
auto matches = [callback](const auto& cb) {
return cb->asBinder() == callback->asBinder(); // compares binder object
};
bool removed = false;
for (auto it = callbacks_.begin(); it != callbacks_.end();) {
if (it->second->asBinder() == callback->asBinder()) {
auto status = AIBinder_unlinkToDeath(callback->asBinder().get(), death_recipient_.get(),
reinterpret_cast<void*>(it->first));
if (status != STATUS_OK && status != STATUS_DEAD_OBJECT) {
LOG(WARNING) << __func__
<< "Cannot unlink to death: " << ::android::statusToString(status);
}
it = callbacks_.erase(it);
removed = true;
} else {
it++;
}
}
return removed ? ndk::ScopedAStatus::ok()
: ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
}
// A combination of the HIDL version
// android::hardware::health::V2_1::implementation::Health::update() and
// android::hardware::health::V2_1::implementation::BinderHealth::update()
ndk::ScopedAStatus Health::update() {
HealthInfo health_info;
if (auto res = getHealthInfo(&health_info); !res.isOk()) {
LOG(DEBUG) << "Cannot call getHealthInfo for update(): " << res.getDescription();
// Propagate service specific errors. If there's none, report unknown error.
if (res.getServiceSpecificError() != 0 ||
res.getExceptionCode() == EX_UNSUPPORTED_OPERATION) {
return res;
}
return ndk::ScopedAStatus::fromServiceSpecificErrorWithMessage(
IHealth::STATUS_UNKNOWN, res.getDescription().c_str());
}
battery_monitor_.logValues();
OnHealthInfoChanged(health_info);
return ndk::ScopedAStatus::ok();
}
void Health::OnHealthInfoChanged(const HealthInfo& health_info) {
// Notify all callbacks
std::unique_lock<decltype(callbacks_lock_)> lock(callbacks_lock_);
for (const auto& [_, callback] : callbacks_) {
auto res = callback->healthInfoChanged(health_info);
if (!res.isOk()) {
LOG(DEBUG) << "Cannot call healthInfoChanged:" << res.getDescription()
<< ". Do nothing here if callback is dead as it will be cleaned up later.";
}
}
lock.unlock();
// Let HalHealthLoop::OnHealthInfoChanged() adjusts uevent / wakealarm periods
}
void Health::BinderEvent(uint32_t /*epevents*/) {
if (binder_fd_ >= 0) {
ABinderProcess_handlePolledCommands();
}
}
void Health::OnInit(HalHealthLoop* hal_health_loop, struct healthd_config* config) {
LOG(INFO) << instance_name_ << " instance initializing with healthd_config...";
// Similar to HIDL's android::hardware::health::V2_1::implementation::HalHealthLoop::Init,
// copy configuration parameters to |config| for HealthLoop (e.g. uevent / wake alarm periods)
*config = *healthd_config_.get();
binder_status_t status = ABinderProcess_setupPolling(&binder_fd_);
if (status == ::STATUS_OK && binder_fd_ >= 0) {
std::shared_ptr<Health> thiz = ref<Health>();
auto binder_event = [thiz](auto*, uint32_t epevents) { thiz->BinderEvent(epevents); };
if (hal_health_loop->RegisterEvent(binder_fd_, binder_event, EVENT_NO_WAKEUP_FD) != 0) {
PLOG(ERROR) << instance_name_ << " instance: Register for binder events failed";
}
}
std::string health_name = IHealth::descriptor + "/"s + instance_name_;
CHECK_EQ(STATUS_OK, AServiceManager_addService(this->asBinder().get(), health_name.c_str()))
<< instance_name_ << ": Failed to register HAL";
LOG(INFO) << instance_name_ << ": Hal init done";
}
// Unlike hwbinder, for binder, there's no need to explicitly call flushCommands()
// in PrepareToWait(). See b/139697085.
} // namespace aidl::android::hardware::health