Battery
Introduction
This repository contains the Battery module HDI (Hardware Driver Interface) definitions and implementations, providing battery management driver capability interfaces for upper-layer system services. The Battery HDI interfaces mainly include:
- Battery Info: Responsible for obtaining various battery information, including capacity, voltage, temperature, health state, charging state, etc.
- Battery Config: Responsible for battery configuration management, supporting getting and setting battery configuration items.
- Callback: Responsible for battery event change callback notifications.
Directory
The source code directory structure is as follows:
/drivers/peripheral/battery
├── interfaces # Battery module driver capability interfaces for upper-layer services
│ └── hdi_service # HDI layer framework code
│ ├── include # Header files
│ ├── profile # Configuration files
│ ├── src # HDI layer source code
│ └── test # Test code
│ ├── unittest # Unit tests
│ ├── systemtest # System tests
│ └── fuzztest # Fuzz tests
└── utils # Utility code
Interface Description
The Battery driver module provides interfaces to upper-layer system services through the HDI layer, with main functions including: obtaining battery information, setting charging limits, battery configuration management, etc. The provided interfaces are shown in Table1 Battery HDI Interface List:
Table 1 Battery HDI Interface List
Usage Instructions
The core function of this repository is to provide battery management driver capability interfaces for upper-layer system services. The provided driver capability interfaces are unified as HDI interface layer.
The following sample code demonstrates how to use the Battery HDI interface:
#include "v2_0/ibattery_interface.h"
#include "battery_hdi_client.h"
using namespace OHOS::HDI::Battery::V2_0;
class BatteryCallbackImpl : public IBatteryCallback {
public:
int32_t OnBatteryCallback(const BatteryInfo& event) override
{
HDF_LOGI("BatteryCallback: capacity=%{public}d, voltage=%{public}d, temperature=%{public}d",
event.capacity, event.voltage, event.temperature);
return 0;
}
};
static int32_t BatteryHdiSample(void)
{
int32_t ret;
sptr<IBatteryInterface> g_batteryInterface = BatteryHdiClient::GetInstance();
if (g_batteryInterface == nullptr) {
HDF_LOGE("get battery interface failed");
return HDF_FAILURE;
}
// Register battery callback
sptr<IBatteryCallback> callback = new (std::nothrow) BatteryCallbackImpl();
ret = g_batteryInterface->Register(callback);
if (ret != HDF_SUCCESS) {
HDF_LOGE("register battery callback failed");
return ret;
}
// Get battery capacity
int32_t capacity;
ret = g_batteryInterface->GetCapacity(capacity);
if (ret != HDF_SUCCESS) {
HDF_LOGE("get capacity failed");
return ret;
}
// Get battery voltage
int32_t voltage;
ret = g_batteryInterface->GetVoltage(voltage);
if (ret != HDF_SUCCESS) {
HDF_LOGE("get voltage failed");
return ret;
}
// Get battery temperature
int32_t temperature;
ret = g_batteryInterface->GetTemperature(temperature);
if (ret != HDF_SUCCESS) {
HDF_LOGE("get temperature failed");
return ret;
}
// Get health state
BatteryHealthState healthState;
ret = g_batteryInterface->GetHealthState(healthState);
if (ret != HDF_SUCCESS) {
HDF_LOGE("get health state failed");
return ret;
}
// Get charge state
BatteryChargeState chargeState;
ret = g_batteryInterface->GetChargeState(chargeState);
if (ret != HDF_SUCCESS) {
HDF_LOGE("get charge state failed");
return ret;
}
// Get if battery is present
bool present;
ret = g_batteryInterface->GetPresent(present);
if (ret != HDF_SUCCESS) {
HDF_LOGE("get present failed");
return ret;
}
// Get battery technology
std::string technology;
ret = g_batteryInterface->GetTechnology(technology);
if (ret != HDF_SUCCESS) {
HDF_LOGE("get technology failed");
return ret;
}
// Get charge type
ChargeType chargeType;
ret = g_batteryInterface->GetChargeType(chargeType);
if (ret != HDF_SUCCESS) {
HDF_LOGE("get charge type failed");
return ret;
}
// Get average current
int32_t curAverage;
ret = g_batteryInterface->GetCurrentAverage(curAverage);
if (ret != HDF_SUCCESS) {
HDF_LOGE("get current average failed");
return ret;
}
// Get instantaneous current
int32_t curNow;
ret = g_batteryInterface->GetCurrentNow(curNow);
if (ret != HDF_SUCCESS) {
HDF_LOGE("get current now failed");
return ret;
}
// Get battery info
BatteryInfo info;
ret = g_batteryInterface->GetBatteryInfo(info);
if (ret != HDF_SUCCESS) {
HDF_LOGE("get battery info failed");
return ret;
}
// Get battery config
std::string value;
ret = g_batteryInterface->GetBatteryConfig("scene_name", value);
if (ret != HDF_SUCCESS) {
HDF_LOGE("get battery config failed");
return ret;
}
// Set battery config
ret = g_batteryInterface->SetBatteryConfig("scene_name", "value");
if (ret != HDF_SUCCESS) {
HDF_LOGE("set battery config failed");
return ret;
}
// Check if battery config is supported
bool isSupported;
ret = g_batteryInterface->IsBatteryConfigSupported("scene_name", isSupported);
if (ret != HDF_SUCCESS) {
HDF_LOGE("check battery config supported failed");
return ret;
}
// Unregister battery callback
ret = g_batteryInterface->UnRegister();
if (ret != HDF_SUCCESS) {
HDF_LOGE("unregister battery callback failed");
return ret;
}
return HDF_SUCCESS;
}