openharmony/powermgr_battery_manager
1
0
Fork 0
mirror of https://github.com/openharmony/powermgr_battery_manager.git synced 2026-07-01 06:42:05 -04:00
Code Issues Packages Projects Releases Wiki Activity

style: battery_manager仓 IDL化

Browse Source 
Signed-off-by: 张全超 <zhangquanchao@huawei.com>
This commit is contained in:
yxj
2025-06-27 15:15:27 +08:00
parent 11a9cbbdc1
commit 4ae8c8fdc1
47 changed files with 1647 additions and 1141 deletions
Download Patch File Download Diff File Expand all files Collapse all files
bundle.json
+1 -2
View File
@@ -98,8 +98,7 @@
"header": {
"header_files": [
"battery_info.h",
"battery_srv_client.h",
"ibattery_srv.h"
"battery_srv_client.h"
],
"header_base": "//base/powermgr/battery_manager/interfaces/inner_api/native/include"
}
frameworks/native/src/battery_srv_client.cpp
+112 -16
View File
@@ -90,112 +90,208 @@ int32_t BatterySrvClient::GetCapacity()
{
auto proxy = Connect();
RETURN_IF_WITH_RET(proxy == nullptr, INVALID_BATT_INT_VALUE);
return proxy->GetCapacity();
int32_t capacity = INVALID_BATT_INT_VALUE;
auto ret = proxy->GetCapacity(capacity);
if (ret != ERR_OK) {
BATTERY_HILOGE(COMP_FWK, "GetCapacity ret = %{public}d", ret);
return INVALID_BATT_INT_VALUE;
}
return capacity;
}
BatteryChargeState BatterySrvClient::GetChargingStatus()
{
auto proxy = Connect();
RETURN_IF_WITH_RET(proxy == nullptr, BatteryChargeState::CHARGE_STATE_BUTT);
return proxy->GetChargingStatus();
uint32_t chargeState = static_cast<uint32_t>(BatteryChargeState::CHARGE_STATE_BUTT);
auto ret = proxy->GetChargingStatus(chargeState);
if (ret != ERR_OK) {
BATTERY_HILOGE(COMP_FWK, "GetChargingStatus ret = %{public}d", ret);
return BatteryChargeState::CHARGE_STATE_BUTT;
}
return static_cast<BatteryChargeState>(chargeState);
}
BatteryHealthState BatterySrvClient::GetHealthStatus()
{
auto proxy = Connect();
RETURN_IF_WITH_RET(proxy == nullptr, BatteryHealthState::HEALTH_STATE_BUTT);
return proxy->GetHealthStatus();
uint32_t healthState = static_cast<uint32_t>(BatteryHealthState::HEALTH_STATE_BUTT);
auto ret = proxy->GetHealthStatus(healthState);
if (ret != ERR_OK) {
BATTERY_HILOGE(COMP_FWK, "GetHealthStatus ret = %{public}d", ret);
return BatteryHealthState::HEALTH_STATE_BUTT;
}
return static_cast<BatteryHealthState>(healthState);
}
BatteryPluggedType BatterySrvClient::GetPluggedType()
{
auto proxy = Connect();
RETURN_IF_WITH_RET(proxy == nullptr, BatteryPluggedType::PLUGGED_TYPE_BUTT);
return proxy->GetPluggedType();
uint32_t pluggedType = static_cast<uint32_t>(BatteryPluggedType::PLUGGED_TYPE_BUTT);
auto ret = proxy->GetPluggedType(pluggedType);
if (ret != ERR_OK) {
BATTERY_HILOGE(COMP_FWK, "GetPluggedType ret = %{public}d", ret);
return BatteryPluggedType::PLUGGED_TYPE_BUTT;
}
return static_cast<BatteryPluggedType>(pluggedType);
}
int32_t BatterySrvClient::GetVoltage()
{
auto proxy = Connect();
RETURN_IF_WITH_RET(proxy == nullptr, INVALID_BATT_INT_VALUE);
return proxy->GetVoltage();
int32_t voltage = INVALID_BATT_INT_VALUE;
auto ret = proxy->GetVoltage(voltage);
if (ret != ERR_OK) {
BATTERY_HILOGE(COMP_FWK, "GetVoltage ret = %{public}d", ret);
return INVALID_BATT_INT_VALUE;
}
return voltage;
}
bool BatterySrvClient::GetPresent()
{
auto proxy = Connect();
RETURN_IF_WITH_RET(proxy == nullptr, INVALID_BATT_BOOL_VALUE);
return proxy->GetPresent();
bool present = INVALID_BATT_BOOL_VALUE;
auto ret = proxy->GetPresent(present);
if (ret != ERR_OK) {
BATTERY_HILOGE(COMP_FWK, "GetPresent ret = %{public}d", ret);
return INVALID_BATT_BOOL_VALUE;
}
return present;
}
std::string BatterySrvClient::GetTechnology()
{
auto proxy = Connect();
RETURN_IF_WITH_RET(proxy == nullptr, "");
return proxy->GetTechnology();
std::string technology = INVALID_STRING_VALUE;
auto ret = proxy->GetTechnology(technology);
if (ret != ERR_OK) {
BATTERY_HILOGE(COMP_FWK, "GetTechnology ret = %{public}d", ret);
return INVALID_STRING_VALUE;
}
return technology;
}
int32_t BatterySrvClient::GetBatteryTemperature()
{
auto proxy = Connect();
RETURN_IF_WITH_RET(proxy == nullptr, INVALID_BATT_TEMP_VALUE);
return proxy->GetBatteryTemperature();
int32_t temperature = INVALID_BATT_TEMP_VALUE;
auto ret = proxy->GetBatteryTemperature(temperature);
if (ret != ERR_OK) {
BATTERY_HILOGE(COMP_FWK, "GetBatteryTemperature ret = %{public}d", ret);
return INVALID_BATT_TEMP_VALUE;
}
return temperature;
}
int32_t BatterySrvClient::GetNowCurrent()
{
auto proxy = Connect();
RETURN_IF_WITH_RET(proxy == nullptr, INVALID_BATT_INT_VALUE);
return proxy->GetNowCurrent();
int32_t nowCurr = INVALID_BATT_INT_VALUE;
auto ret = proxy->GetNowCurrent(nowCurr);
if (ret != ERR_OK) {
BATTERY_HILOGE(COMP_FWK, "GetNowCurrent ret = %{public}d", ret);
return INVALID_BATT_INT_VALUE;
}
return nowCurr;
}
int32_t BatterySrvClient::GetRemainEnergy()
{
auto proxy = Connect();
RETURN_IF_WITH_RET(proxy == nullptr, INVALID_BATT_INT_VALUE);
return proxy->GetRemainEnergy();
int32_t remainEnergy = INVALID_BATT_INT_VALUE;
auto ret = proxy->GetRemainEnergy(remainEnergy);
if (ret != ERR_OK) {
BATTERY_HILOGE(COMP_FWK, "GetRemainEnergy ret = %{public}d", ret);
return INVALID_BATT_INT_VALUE;
}
return remainEnergy;
}
int32_t BatterySrvClient::GetTotalEnergy()
{
auto proxy = Connect();
RETURN_IF_WITH_RET(proxy == nullptr, INVALID_BATT_INT_VALUE);
return proxy->GetTotalEnergy();
int32_t totalEnergy = INVALID_BATT_INT_VALUE;
auto ret = proxy->GetTotalEnergy(totalEnergy);
if (ret != ERR_OK) {
BATTERY_HILOGE(COMP_FWK, "GetTotalEnergy ret = %{public}d", ret);
return INVALID_BATT_INT_VALUE;
}
return totalEnergy;
}
BatteryCapacityLevel BatterySrvClient::GetCapacityLevel()
{
auto proxy = Connect();
RETURN_IF_WITH_RET(proxy == nullptr, BatteryCapacityLevel::LEVEL_NONE);
return proxy->GetCapacityLevel();
uint32_t batteryCapacityLevel = static_cast<uint32_t>(BatteryCapacityLevel::LEVEL_NONE);
auto ret = proxy->GetCapacityLevel(batteryCapacityLevel);
if (ret != ERR_OK) {
BATTERY_HILOGE(COMP_FWK, "GetCapacityLevel ret = %{public}d", ret);
return BatteryCapacityLevel::LEVEL_NONE;
}
return static_cast<BatteryCapacityLevel>(batteryCapacityLevel);
}
int64_t BatterySrvClient::GetRemainingChargeTime()
{
auto proxy = Connect();
RETURN_IF_WITH_RET(proxy == nullptr, INVALID_REMAINING_CHARGE_TIME_VALUE);
return proxy->GetRemainingChargeTime();
int64_t remainTime = INVALID_REMAINING_CHARGE_TIME_VALUE;
auto ret = proxy->GetRemainingChargeTime(remainTime);
if (ret != ERR_OK) {
BATTERY_HILOGE(COMP_FWK, "GetRemainingChargeTime ret = %{public}d", ret);
return INVALID_REMAINING_CHARGE_TIME_VALUE;
}
return remainTime;
}
BatteryError BatterySrvClient::SetBatteryConfig(const std::string& sceneName, const std::string& value)
{
auto proxy = Connect();
RETURN_IF_WITH_RET(proxy == nullptr, BatteryError::ERR_CONNECTION_FAIL);
return proxy->SetBatteryConfig(sceneName, value);
int32_t batteryErr = static_cast<int32_t>(BatteryError::ERR_CONNECTION_FAIL);
auto ret = proxy->SetBatteryConfig(sceneName, value, batteryErr);
if (ret != ERR_OK) {
BATTERY_HILOGE(COMP_FWK, "SetBatteryConfig ret = %{public}d", ret);
return BatteryError::ERR_CONNECTION_FAIL;
}
return static_cast<BatteryError>(batteryErr);
}
BatteryError BatterySrvClient::GetBatteryConfig(const std::string& sceneName, std::string& result)
{
auto proxy = Connect();
RETURN_IF_WITH_RET(proxy == nullptr, BatteryError::ERR_CONNECTION_FAIL);
return proxy->GetBatteryConfig(sceneName, result);
int32_t batteryErr = static_cast<int32_t>(BatteryError::ERR_CONNECTION_FAIL);
auto ret = proxy->GetBatteryConfig(sceneName, result, batteryErr);
if (ret != ERR_OK) {
BATTERY_HILOGE(COMP_FWK, "GetBatteryConfig ret = %{public}d", ret);
return BatteryError::ERR_CONNECTION_FAIL;
}
return static_cast<BatteryError>(batteryErr);
}
BatteryError BatterySrvClient::IsBatteryConfigSupported(const std::string& sceneName, bool& result)
{
auto proxy = Connect();
RETURN_IF_WITH_RET(proxy == nullptr, BatteryError::ERR_CONNECTION_FAIL);
return proxy->IsBatteryConfigSupported(sceneName, result);
int32_t batteryErr = static_cast<int32_t>(BatteryError::ERR_CONNECTION_FAIL);
auto ret = proxy->IsBatteryConfigSupported(sceneName, result, batteryErr);
if (ret != ERR_OK) {
BATTERY_HILOGE(COMP_FWK, "IsBatteryConfigSupported ret = %{public}d", ret);
return BatteryError::ERR_CONNECTION_FAIL;
}
return static_cast<BatteryError>(batteryErr);
}
} // namespace PowerMgr
} // namespace OHOS
interfaces/inner_api/BUILD.gn
+11 -8
View File
@@ -14,23 +14,26 @@
import("../../batterymgr.gni")
config("batterysrv_public_config") {
include_dirs = [
"native/include",
"${battery_service_zidl}/include",
]
include_dirs = [ "native/include" ]
}
ohos_shared_library("batterysrv_client") {
sanitize = {
cfi = true
cfi_cross_dso = true
debug = false
}
branch_protector_ret = "pac_ret"
sources = [
"${battery_frameworks}/native/src/battery_srv_client.cpp",
"${battery_service_zidl}/src/battery_srv_proxy.cpp",
]
sources = [ "${battery_frameworks}/native/src/battery_srv_client.cpp" ]
deps = [ "${battery_service_zidl}:batterysrv_proxy" ]
configs = [ "${battery_utils}:coverage_flags" ]
public_configs = [
"${battery_service_zidl}:batterysrv_public_config",
"${battery_utils}:utils_config",
":batterysrv_public_config",
]
interfaces/inner_api/native/include/battery_manager_ipc_interface_code.h
-44
View File
@@ -1,44 +0,0 @@
/*
* Copyright (c) 2023 Huawei Device Co., Ltd.
* 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.
*/
#ifndef BATTERY_MANAGER_IPC_INTERFACE_DODE_H
#define BATTERY_MANAGER_IPC_INTERFACE_DODE_H
/* SAID: 3302 */
namespace OHOS {
namespace PowerMgr {
enum class BatterySrvInterfaceCode {
BATT_GET_CAPACITY = 0,
BATT_GET_CHARGING_STATUS,
BATT_GET_HEALTH_STATUS,
BATT_GET_PLUG_TYPE,
BATT_GET_VOLTAGE,
BATT_GET_PRESENT,
BATT_GET_TEMPERATURE,
BATT_GET_TECHNOLOGY,
BATT_GET_BATTERY_LEVEL,
BATT_GET_REMAINING_CHARGE_TIME,
BATT_GET_BATTERY_TOTAL_ENERGY,
BATT_GET_BATTERY_CURRENT_AVERAGE,
BATT_GET_BATTERY_CURRENT_NOW,
BATT_GET_BATTERY_REMAIN_ENERGY,
SET_BATTERY_CONFIG,
GET_BATTERY_CONFIG,
SUPPORT_BATTERY_CONFIG
};
} // space PowerMgr
} // namespace OHOS
#endif // BATTERY_MANAGER_IPC_INTERFACE_DODE_H
interfaces/inner_api/native/include/battery_srv_client.h
+3 -1
View File
@@ -19,6 +19,8 @@
#include <singleton.h>
#include <memory>
#include <mutex>
#include "battery_info.h"
#include "battery_srv_errors.h"
#include "iremote_object.h"
#include "ibattery_srv.h"
@@ -65,7 +67,7 @@ public:
* Return the temperature of the battery, in 0.1℃.
*/
int32_t GetBatteryTemperature();
/**
/**
* Return the Current of the battery, in mA.
*/
int32_t GetNowCurrent();
interfaces/inner_api/native/include/ibattery_srv.h
-52
View File
@@ -1,52 +0,0 @@
/*
* Copyright (c) 2021 Huawei Device Co., Ltd.
* 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.
*/
#ifndef POWERMGR_INNER_API_IBATTERY_SRV_H
#define POWERMGR_INNER_API_IBATTERY_SRV_H
#include <string>
#include "iremote_broker.h"
#include "iremote_object.h"
#include "battery_info.h"
#include "battery_srv_errors.h"
namespace OHOS {
namespace PowerMgr {
class IBatterySrv : public IRemoteBroker {
public:
virtual int32_t GetCapacity() = 0;
virtual BatteryChargeState GetChargingStatus() = 0;
virtual BatteryHealthState GetHealthStatus() = 0;
virtual BatteryPluggedType GetPluggedType() = 0;
virtual int32_t GetVoltage() = 0;
virtual bool GetPresent() = 0;
virtual std::string GetTechnology() = 0;
virtual int32_t GetTotalEnergy() = 0;
virtual int32_t GetCurrentAverage() = 0;
virtual int32_t GetNowCurrent() = 0;
virtual int32_t GetRemainEnergy() = 0;
virtual int32_t GetBatteryTemperature() = 0;
virtual BatteryCapacityLevel GetCapacityLevel() = 0;
virtual int64_t GetRemainingChargeTime() = 0;
virtual BatteryError SetBatteryConfig(const std::string& sceneName, const std::string& value) = 0;
virtual BatteryError GetBatteryConfig(const std::string& sceneName, std::string& result) = 0;
virtual BatteryError IsBatteryConfigSupported(const std::string& featureName, bool& result) = 0;
public:
DECLARE_INTERFACE_DESCRIPTOR(u"ohos.powermgr.IBatterySrv");
};
} // space PowerMgr
} // namespace OHOS
#endif // POWERMGR_INNER_API_IBATTERY_SRV_H
services/BUILD.gn
+5 -2
View File
@@ -17,7 +17,6 @@ config("batterysrv_public_config") {
include_dirs = [
"native/include",
"native/notification",
"${battery_service_zidl}/include",
"${battery_inner_api}/native/include",
]
}
@@ -56,6 +55,7 @@ ohos_shared_library("batteryservice") {
branch_protector_ret = "pac_ret"
sources = [
"${battery_utils}/native/src/battery_xcollie.cpp",
"native/src/battery_callback.cpp",
"native/src/battery_config.cpp",
"native/src/battery_dump.cpp",
@@ -69,7 +69,10 @@ ohos_shared_library("batteryservice") {
"${battery_utils}:coverage_flags",
]
public_configs = [ ":batterysrv_public_config" ]
public_configs = [
"${battery_service_zidl}:batterysrv_public_config",
":batterysrv_public_config",
]
deps = [
"${battery_service_zidl}:batterysrv_stub",
services/native/include/battery_dump.h
+1
View File
@@ -36,6 +36,7 @@ public:
bool Reset(int32_t fd, sptr<BatteryService> &service, const std::vector<std::u16string> &args);
bool MockCapacity(int32_t fd, sptr<BatteryService> &service, const std::vector<std::u16string> &args);
bool MockUevent(int32_t fd, sptr<BatteryService> &service, const std::vector<std::u16string> &args);
void DumpBatteryInfo(sptr<BatteryService> &service, int32_t fd);
private:
void DumpCurrentTime(int32_t fd);
services/native/include/battery_service.h
+40 -17
View File
@@ -33,7 +33,9 @@
#include "battery_info.h"
#include "battery_light.h"
#include "battery_notify.h"
#include "battery_srv_errors.h"
#include "battery_srv_stub.h"
#include "battery_xcollie.h"
#include "ibattery_srv.h"
#include "sp_singleton.h"
#include "v2_0/ibattery_interface.h"
@@ -62,25 +64,45 @@ public:
}
int32_t Dump(int fd, const std::vector<std::u16string> &args) override;
int32_t GetCapacity() override;
BatteryChargeState GetChargingStatus() override;
BatteryHealthState GetHealthStatus() override;
BatteryPluggedType GetPluggedType() override;
int32_t GetVoltage() override;
bool GetPresent() override;
std::string GetTechnology() override;
int32_t GetTotalEnergy() override;
int32_t GetCurrentAverage() override;
int32_t GetNowCurrent() override;
int32_t GetRemainEnergy() override;
int32_t GetBatteryTemperature() override;
BatteryCapacityLevel GetCapacityLevel() override;
int64_t GetRemainingChargeTime() override;
ChargeType GetChargeType();
bool ChangePath(const std::string path);
BatteryError SetBatteryConfig(const std::string& sceneName, const std::string& value) override;
BatteryError GetBatteryConfig(const std::string& sceneName, std::string& result) override;
BatteryError IsBatteryConfigSupported(const std::string& sceneName, bool& result) override;
private:
int32_t GetCapacityInner();
BatteryChargeState GetChargingStatusInner();
BatteryHealthState GetHealthStatusInner();
BatteryPluggedType GetPluggedTypeInner();
int32_t GetVoltageInner();
bool GetPresentInner();
std::string GetTechnologyInner();
int32_t GetTotalEnergyInner();
int32_t GetCurrentAverageInner();
int32_t GetNowCurrentInner();
int32_t GetRemainEnergyInner();
int32_t GetBatteryTemperatureInner();
BatteryCapacityLevel GetCapacityLevelInner();
int64_t GetRemainingChargeTimeInner();
BatteryError SetBatteryConfigInner(const std::string& sceneName, const std::string& value);
BatteryError GetBatteryConfigInner(const std::string& sceneName, std::string& result);
BatteryError IsBatteryConfigSupportedInner(const std::string& sceneName, bool& result);
public:
int32_t GetCapacity(int32_t& capacity) override;
int32_t GetChargingStatus(uint32_t& chargeState) override;
int32_t GetHealthStatus(uint32_t& healthState) override;
int32_t GetPluggedType(uint32_t& pluggedType) override;
int32_t GetVoltage(int32_t& voltage) override;
int32_t GetPresent(bool& present) override;
int32_t GetTechnology(std::string& technology) override;
int32_t GetTotalEnergy(int32_t& totalEnergy) override;
int32_t GetCurrentAverage(int32_t& curAverage) override;
int32_t GetNowCurrent(int32_t& nowCurr) override;
int32_t GetRemainEnergy(int32_t& remainEnergy) override;
int32_t GetBatteryTemperature(int32_t& temperature) override;
int32_t GetCapacityLevel(uint32_t& batteryCapacityLevel) override;
int32_t GetRemainingChargeTime(int64_t& remainTime) override;
int32_t SetBatteryConfig(const std::string& sceneName, const std::string& value, int32_t& batteryErr) override;
int32_t GetBatteryConfig(const std::string& sceneName, std::string& result, int32_t& batteryErr) override;
int32_t IsBatteryConfigSupported(const std::string& featureName, bool& result, int32_t& batteryErr) override;
void InitConfig();
void HandleTemperature(int32_t temperature);
bool RegisterHdiStatusListener();
@@ -118,6 +140,7 @@ private:
#ifdef BATTERY_MANAGER_SET_LOW_CAPACITY_THRESHOLD
void SetLowCapacityThreshold();
#endif
bool CapacityLevelCompare(int32_t capacity, int32_t minCapacity, int32_t maxCapacity);
bool ready_ { false };
static std::atomic_bool isBootCompleted_;
std::shared_mutex mutex_;
services/native/src/battery_dump.cpp
+49 -30
View File
@@ -59,6 +59,54 @@ void BatteryDump::DumpCurrentTime(int32_t fd)
int32_t { (curTime.tv_nsec / MS_NS) });
}
void BatteryDump::DumpBatteryInfo(sptr<BatteryService> &service, int32_t fd)
{
int32_t capacity = 0;
service->GetCapacity(capacity);
dprintf(fd, "capacity: %d \n", capacity);
uint32_t batteryLevel = static_cast<uint32_t>(BatteryCapacityLevel::LEVEL_NONE);
service->GetCapacityLevel(batteryLevel);
dprintf(fd, "batteryLevel: %u \n", batteryLevel);
uint32_t chargingStatus = static_cast<uint32_t>(BatteryChargeState::CHARGE_STATE_NONE);
service->GetChargingStatus(chargingStatus);
dprintf(fd, "chargingStatus: %u \n", chargingStatus);
uint32_t healthState = static_cast<uint32_t>(BatteryHealthState::HEALTH_STATE_UNKNOWN);
service->GetHealthStatus(healthState);
dprintf(fd, "healthState: %u \n", healthState);
uint32_t pluggedType = static_cast<uint32_t>(BatteryPluggedType::PLUGGED_TYPE_NONE);
service->GetPluggedType(pluggedType);
dprintf(fd, "pluggedType: %u \n", pluggedType);
int32_t voltage = INVALID_BATT_INT_VALUE;
service->GetVoltage(voltage);
dprintf(fd, "voltage: %d \n", voltage);
bool present = false;
service->GetPresent(present);
dprintf(fd, "present: %d \n", present);
std::string technology;
service->GetTechnology(technology);
dprintf(fd, "technology: %s \n", technology.c_str());
int32_t nowCurrent = INVALID_BATT_INT_VALUE;
service->GetNowCurrent(nowCurrent);
dprintf(fd, "nowCurrent: %d \n", nowCurrent);
int32_t currentAverage = INVALID_BATT_INT_VALUE;
service->GetCurrentAverage(currentAverage);
dprintf(fd, "currentAverage: %d \n", currentAverage);
int32_t totalEnergy = INVALID_BATT_INT_VALUE;
service->GetTotalEnergy(totalEnergy);
dprintf(fd, "totalEnergy: %d \n", totalEnergy);
int32_t remainEnergy = INVALID_BATT_INT_VALUE;
service->GetRemainEnergy(remainEnergy);
dprintf(fd, "remainingEnergy: %d \n", remainEnergy);
int64_t remainingChargeTime = INVALID_REMAINING_CHARGE_TIME_VALUE;
service->GetRemainingChargeTime(remainingChargeTime);
dprintf(fd, "remainingChargeTime: %ld \n", remainingChargeTime);
int32_t temperature = INVALID_BATT_INT_VALUE;
service->GetBatteryTemperature(temperature);
dprintf(fd, "temperature: %d \n", temperature);
ChargeType chargeType = service->GetChargeType();
dprintf(fd, "chargeType: %u \n", chargeType);
}
bool BatteryDump::GetBatteryInfo(int32_t fd, sptr<BatteryService> &service, const std::vector<std::u16string> &args)
{
if ((args.empty()) || (args[0].compare(u"-i") != 0)) {
@@ -66,36 +114,7 @@ bool BatteryDump::GetBatteryInfo(int32_t fd, sptr<BatteryService> &service, cons
return false;
}
DumpCurrentTime(fd);
int32_t capacity = service->GetCapacity();
dprintf(fd, "capacity: %u \n", capacity);
BatteryCapacityLevel batteryLevel = service->GetCapacityLevel();
dprintf(fd, "batteryLevel: %u \n", batteryLevel);
BatteryChargeState chargingStatus = service->GetChargingStatus();
dprintf(fd, "chargingStatus: %u \n", chargingStatus);
BatteryHealthState healthState = service->GetHealthStatus();
dprintf(fd, "healthState: %u \n", healthState);
BatteryPluggedType pluggedType = service->GetPluggedType();
dprintf(fd, "pluggedType: %u \n", pluggedType);
int32_t voltage = service->GetVoltage();
dprintf(fd, "voltage: %d \n", voltage);
bool present = service->GetPresent();
dprintf(fd, "present: %d \n", present);
std::string technology = service->GetTechnology();
dprintf(fd, "technology: %s \n", technology.c_str());
int32_t nowCurrent = service->GetNowCurrent();
dprintf(fd, "nowCurrent: %d \n", nowCurrent);
int32_t currentAverage = service->GetCurrentAverage();
dprintf(fd, "currentAverage: %d \n", currentAverage);
int32_t totalEnergy = service->GetTotalEnergy();
dprintf(fd, "totalEnergy: %d \n", totalEnergy);
int32_t remainEnergy = service->GetRemainEnergy();
dprintf(fd, "remainingEnergy: %d \n", remainEnergy);
int64_t remainingChargeTime = service->GetRemainingChargeTime();
dprintf(fd, "remainingChargeTime: %ld \n", remainingChargeTime);
int32_t temperature = service->GetBatteryTemperature();
dprintf(fd, "temperature: %d \n", temperature);
ChargeType chargeType = service->GetChargeType();
dprintf(fd, "chargeType: %u \n", chargeType);
DumpBatteryInfo(service, fd);
return true;
}
services/native/src/battery_notify.cpp
+4 -3
View File
@@ -217,10 +217,11 @@ bool BatteryNotify::PublishChangedEvent(const BatteryInfo& info)
want.SetParam(BatteryInfo::COMMON_EVENT_KEY_TECHNOLOGY, info.GetTechnology());
want.SetParam(BatteryInfo::COMMON_EVENT_KEY_UEVENT, info.GetUevent());
auto capacityLevel = g_service->GetCapacityLevel();
if (capacityLevel != g_lastCapacityLevel) {
auto capacityLevel = static_cast<uint32_t>(BatteryCapacityLevel::LEVEL_NONE);
g_service->GetCapacityLevel(capacityLevel);
if (static_cast<BatteryCapacityLevel>(capacityLevel) != g_lastCapacityLevel) {
want.SetParam(BatteryInfo::COMMON_EVENT_KEY_CAPACITY_LEVEL, static_cast<int32_t>(capacityLevel));
g_lastCapacityLevel = capacityLevel;
g_lastCapacityLevel = static_cast<BatteryCapacityLevel>(capacityLevel);
}
want.SetAction(CommonEventSupport::COMMON_EVENT_BATTERY_CHANGED);
services/native/src/battery_service.cpp
+172 -44
View File
@@ -250,18 +250,18 @@ void BatteryService::ConvertingEvent(const V2_0::BatteryInfo& event)
void BatteryService::InitBatteryInfo()
{
batteryInfo_.SetCapacity(GetCapacity());
batteryInfo_.SetPluggedType(GetPluggedType());
batteryInfo_.SetChargeState(GetChargingStatus());
batteryInfo_.SetVoltage(GetVoltage());
batteryInfo_.SetTemperature(GetBatteryTemperature());
batteryInfo_.SetHealthState(GetHealthStatus());
batteryInfo_.SetTotalEnergy(GetTotalEnergy());
batteryInfo_.SetCurAverage(GetCurrentAverage());
batteryInfo_.SetRemainEnergy(GetRemainEnergy());
batteryInfo_.SetPresent(GetPresent());
batteryInfo_.SetTechnology(GetTechnology());
batteryInfo_.SetNowCurrent(GetNowCurrent());
batteryInfo_.SetCapacity(GetCapacityInner());
batteryInfo_.SetPluggedType(GetPluggedTypeInner());
batteryInfo_.SetChargeState(GetChargingStatusInner());
batteryInfo_.SetVoltage(GetVoltageInner());
batteryInfo_.SetTemperature(GetBatteryTemperatureInner());
batteryInfo_.SetHealthState(GetHealthStatusInner());
batteryInfo_.SetTotalEnergy(GetTotalEnergyInner());
batteryInfo_.SetCurAverage(GetCurrentAverageInner());
batteryInfo_.SetRemainEnergy(GetRemainEnergyInner());
batteryInfo_.SetPresent(GetPresentInner());
batteryInfo_.SetTechnology(GetTechnologyInner());
batteryInfo_.SetNowCurrent(GetNowCurrentInner());
batteryInfo_.SetChargeType(GetChargeType());
AddBootCommonEvents();
HandleBatteryInfo();
@@ -295,7 +295,7 @@ bool BatteryService::FillCommonEvent(std::string& ueventName, std::string& commo
commonEventName = iter.eventName;
ueventName = iter.uevent;
std::string result;
BatteryError error = GetBatteryConfig(iter.sceneConfigName, result);
BatteryError error = GetBatteryConfigInner(iter.sceneConfigName, result);
if (error != BatteryError::ERR_OK) {
continue;
}
@@ -556,7 +556,7 @@ void BatteryService::UnlockShutdownGuard()
g_shutdownGuard->UnLock();
}
int32_t BatteryService::GetCapacity()
int32_t BatteryService::GetCapacityInner()
{
if (isMockCapacity_) {
BATTERY_HILOGD(FEATURE_BATT_INFO, "Return mock battery capacity");
@@ -598,7 +598,7 @@ void BatteryService::SetLowCapacityThreshold()
}
#endif
BatteryError BatteryService::SetBatteryConfig(const std::string& sceneName, const std::string& value)
BatteryError BatteryService::SetBatteryConfigInner(const std::string& sceneName, const std::string& value)
{
if (!Permission::IsSystem() || !Permission::IsNativePermissionGranted("ohos.permission.POWER_OPTIMIZATION")) {
BATTERY_HILOGI(FEATURE_BATT_INFO, "SetBatteryConfig failed, System permission intercept");
@@ -616,7 +616,7 @@ BatteryError BatteryService::SetBatteryConfig(const std::string& sceneName, cons
BatteryError::ERR_OK : BatteryError::ERR_FAILURE;
}
BatteryError BatteryService::GetBatteryConfig(const std::string& sceneName, std::string& result)
BatteryError BatteryService::GetBatteryConfigInner(const std::string& sceneName, std::string& result)
{
if (!Permission::IsSystem()) {
BATTERY_HILOGI(FEATURE_BATT_INFO, "GetBatteryConfig failed, System permission intercept");
@@ -639,7 +639,7 @@ BatteryError BatteryService::GetBatteryConfig(const std::string& sceneName, std:
return BatteryError::ERR_OK;
}
BatteryError BatteryService::IsBatteryConfigSupported(const std::string& sceneName, bool& result)
BatteryError BatteryService::IsBatteryConfigSupportedInner(const std::string& sceneName, bool& result)
{
if (!Permission::IsSystem()) {
BATTERY_HILOGI(FEATURE_BATT_INFO, "IsBatteryConfigSupported failed, System permission intercept");
@@ -661,7 +661,7 @@ BatteryError BatteryService::IsBatteryConfigSupported(const std::string& sceneNa
return BatteryError::ERR_OK;
}
BatteryChargeState BatteryService::GetChargingStatus()
BatteryChargeState BatteryService::GetChargingStatusInner()
{
if (isMockUnplugged_) {
BATTERY_HILOGD(FEATURE_BATT_INFO, "Return mock charge status");
@@ -677,7 +677,7 @@ BatteryChargeState BatteryService::GetChargingStatus()
return BatteryChargeState(chargeState);
}
BatteryHealthState BatteryService::GetHealthStatus()
BatteryHealthState BatteryService::GetHealthStatusInner()
{
BATTERY_HILOGD(FEATURE_BATT_INFO, "Enter");
std::shared_lock<std::shared_mutex> lock(mutex_);
@@ -691,7 +691,7 @@ BatteryHealthState BatteryService::GetHealthStatus()
return BatteryHealthState(healthState);
}
BatteryPluggedType BatteryService::GetPluggedType()
BatteryPluggedType BatteryService::GetPluggedTypeInner()
{
if (isMockUnplugged_) {
BATTERY_HILOGD(FEATURE_BATT_INFO, "Return mock plugged type");
@@ -707,7 +707,7 @@ BatteryPluggedType BatteryService::GetPluggedType()
return BatteryPluggedType(pluggedType);
}
int32_t BatteryService::GetVoltage()
int32_t BatteryService::GetVoltageInner()
{
std::shared_lock<std::shared_mutex> lock(mutex_);
if (iBatteryInterface_ == nullptr) {
@@ -719,7 +719,7 @@ int32_t BatteryService::GetVoltage()
return voltage;
}
bool BatteryService::GetPresent()
bool BatteryService::GetPresentInner()
{
std::shared_lock<std::shared_mutex> lock(mutex_);
bool present = false;
@@ -732,7 +732,7 @@ bool BatteryService::GetPresent()
return present;
}
std::string BatteryService::GetTechnology()
std::string BatteryService::GetTechnologyInner()
{
std::shared_lock<std::shared_mutex> lock(mutex_);
if (iBatteryInterface_ == nullptr) {
@@ -745,7 +745,7 @@ std::string BatteryService::GetTechnology()
return technology;
}
int32_t BatteryService::GetBatteryTemperature()
int32_t BatteryService::GetBatteryTemperatureInner()
{
std::shared_lock<std::shared_mutex> lock(mutex_);
if (iBatteryInterface_ == nullptr) {
@@ -757,7 +757,7 @@ int32_t BatteryService::GetBatteryTemperature()
return temperature;
}
int32_t BatteryService::GetTotalEnergy()
int32_t BatteryService::GetTotalEnergyInner()
{
int32_t totalEnergy = INVALID_BATT_INT_VALUE;
if (!Permission::IsSystem()) {
@@ -773,7 +773,7 @@ int32_t BatteryService::GetTotalEnergy()
return totalEnergy;
}
int32_t BatteryService::GetCurrentAverage()
int32_t BatteryService::GetCurrentAverageInner()
{
std::shared_lock<std::shared_mutex> lock(mutex_);
if (iBatteryInterface_ == nullptr) {
@@ -785,7 +785,7 @@ int32_t BatteryService::GetCurrentAverage()
return curAverage;
}
int32_t BatteryService::GetNowCurrent()
int32_t BatteryService::GetNowCurrentInner()
{
int32_t nowCurr = INVALID_BATT_INT_VALUE;
std::shared_lock<std::shared_mutex> lock(mutex_);
@@ -797,7 +797,7 @@ int32_t BatteryService::GetNowCurrent()
return nowCurr;
}
int32_t BatteryService::GetRemainEnergy()
int32_t BatteryService::GetRemainEnergyInner()
{
int32_t remainEnergy = INVALID_BATT_INT_VALUE;
if (!Permission::IsSystem()) {
@@ -857,7 +857,7 @@ void BatteryService::CalculateRemainingChargeTime(int32_t capacity, BatteryCharg
}
}
int64_t BatteryService::GetRemainingChargeTime()
int64_t BatteryService::GetRemainingChargeTimeInner()
{
if (!Permission::IsSystem()) {
BATTERY_HILOGW(FEATURE_BATT_INFO, "system permission denied.");
@@ -871,29 +871,38 @@ bool IsCapacityLevelDefined(int32_t capacityThreshold)
return capacityThreshold != INVALID_BATT_INT_VALUE;
}
BatteryCapacityLevel BatteryService::GetCapacityLevel()
bool BatteryService::CapacityLevelCompare(int32_t capacity, int32_t minCapacity, int32_t maxCapacity)
{
if (IsCapacityLevelDefined(maxCapacity) && capacity > minCapacity && capacity <= maxCapacity) {
return true;
}
return false;
}
BatteryCapacityLevel BatteryService::GetCapacityLevelInner()
{
BatteryCapacityLevel batteryCapacityLevel = BatteryCapacityLevel::LEVEL_NONE;
int32_t capacity = GetCapacity();
if (IsCapacityLevelDefined(shutdownCapacityThreshold_) && capacity > 0 && capacity <= shutdownCapacityThreshold_) {
int32_t capacity = GetCapacityInner();
if (shutdownCapacityThreshold_ <= 0 || criticalCapacityThreshold_ <= shutdownCapacityThreshold_ ||
warningCapacityThreshold_ <= criticalCapacityThreshold_ ||
lowCapacityThreshold_ <= warningCapacityThreshold_ ||
normalCapacityThreshold_ <= lowCapacityThreshold_ || highCapacityThreshold_ <= normalCapacityThreshold_ ||
fullCapacityThreshold_ <= highCapacityThreshold_) {
BATTERY_HILOGE(FEATURE_BATT_INFO, "capacityThreshold err");
}
if (CapacityLevelCompare(capacity, 0, shutdownCapacityThreshold_)) {
batteryCapacityLevel = BatteryCapacityLevel::LEVEL_SHUTDOWN;
} else if (IsCapacityLevelDefined(criticalCapacityThreshold_) && capacity > shutdownCapacityThreshold_ &&
capacity <= criticalCapacityThreshold_) {
} else if (CapacityLevelCompare(capacity, shutdownCapacityThreshold_, criticalCapacityThreshold_)) {
batteryCapacityLevel = BatteryCapacityLevel::LEVEL_CRITICAL;
} else if (IsCapacityLevelDefined(warningCapacityThreshold_) && capacity > criticalCapacityThreshold_ &&
capacity <= warningCapacityThreshold_) {
} else if (CapacityLevelCompare(capacity, criticalCapacityThreshold_, warningCapacityThreshold_)) {
batteryCapacityLevel = BatteryCapacityLevel::LEVEL_WARNING;
} else if (IsCapacityLevelDefined(lowCapacityThreshold_) && capacity > warningCapacityThreshold_ &&
capacity <= lowCapacityThreshold_) {
} else if (CapacityLevelCompare(capacity, warningCapacityThreshold_, lowCapacityThreshold_)) {
batteryCapacityLevel = BatteryCapacityLevel::LEVEL_LOW;
} else if (IsCapacityLevelDefined(normalCapacityThreshold_) && capacity > lowCapacityThreshold_ &&
capacity <= normalCapacityThreshold_) {
} else if (CapacityLevelCompare(capacity, lowCapacityThreshold_, normalCapacityThreshold_)) {
batteryCapacityLevel = BatteryCapacityLevel::LEVEL_NORMAL;
} else if (IsCapacityLevelDefined(highCapacityThreshold_) && capacity > normalCapacityThreshold_ &&
capacity <= highCapacityThreshold_) {
} else if (CapacityLevelCompare(capacity, normalCapacityThreshold_, highCapacityThreshold_)) {
batteryCapacityLevel = BatteryCapacityLevel::LEVEL_HIGH;
} else if (IsCapacityLevelDefined(fullCapacityThreshold_) && capacity > highCapacityThreshold_ &&
capacity <= fullCapacityThreshold_) {
} else if (CapacityLevelCompare(capacity, highCapacityThreshold_, fullCapacityThreshold_)) {
batteryCapacityLevel = BatteryCapacityLevel::LEVEL_FULL;
}
return batteryCapacityLevel;
@@ -1008,5 +1017,124 @@ void BatteryService::VibratorInit()
vibrator->LoadConfig(BATTERY_VIBRATOR_CONFIG_FILE,
VENDOR_BATTERY_VIBRATOR_CONFIG_FILE, SYSTEM_BATTERY_VIBRATOR_CONFIG_FILE);
}
int32_t BatteryService::GetCapacity(int32_t& capacity)
{
BatteryXCollie batteryXCollie("BatteryService::GetCapacity");
capacity = GetCapacityInner();
return ERR_OK;
}
int32_t BatteryService::GetChargingStatus(uint32_t& chargeState)
{
BatteryXCollie batteryXCollie("BatteryService::GetChargingStatus");
chargeState = static_cast<uint32_t>(GetChargingStatusInner());
return ERR_OK;
}
int32_t BatteryService::GetHealthStatus(uint32_t& healthState)
{
BatteryXCollie batteryXCollie("BatteryService::GetHealthStatus");
healthState = static_cast<uint32_t>(GetHealthStatusInner());
return ERR_OK;
}
int32_t BatteryService::GetPluggedType(uint32_t& pluggedType)
{
BatteryXCollie batteryXCollie("BatteryService::GetPluggedType");
pluggedType = static_cast<uint32_t>(GetPluggedTypeInner());
return ERR_OK;
}
int32_t BatteryService::GetVoltage(int32_t& voltage)
{
BatteryXCollie batteryXCollie("BatteryService::GetVoltage");
voltage = GetVoltageInner();
return ERR_OK;
}
int32_t BatteryService::GetPresent(bool& present)
{
BatteryXCollie batteryXCollie("BatteryService::GetPresent");
present = GetPresentInner();
return ERR_OK;
}
int32_t BatteryService::GetTechnology(std::string& technology)
{
BatteryXCollie batteryXCollie("BatteryService::GetTechnology");
technology = GetTechnologyInner();
return ERR_OK;
}
int32_t BatteryService::GetTotalEnergy(int32_t& totalEnergy)
{
BatteryXCollie batteryXCollie("BatteryService::GetTotalEnergy");
totalEnergy = GetTotalEnergyInner();
return ERR_OK;
}
int32_t BatteryService::GetCurrentAverage(int32_t& curAverage)
{
BatteryXCollie batteryXCollie("BatteryService::GetCurrentAverage");
curAverage = GetCurrentAverageInner();
return ERR_OK;
}
int32_t BatteryService::GetNowCurrent(int32_t& nowCurr)
{
BatteryXCollie batteryXCollie("BatteryService::GetNowCurrent");
nowCurr = GetNowCurrentInner();
return ERR_OK;
}
int32_t BatteryService::GetRemainEnergy(int32_t& remainEnergy)
{
BatteryXCollie batteryXCollie("BatteryService::GetRemainEnergy");
remainEnergy= GetRemainEnergyInner();
return ERR_OK;
}
int32_t BatteryService::GetBatteryTemperature(int32_t& temperature)
{
BatteryXCollie batteryXCollie("BatteryService::GetBatteryTemperature");
temperature = GetBatteryTemperatureInner();
return ERR_OK;
}
int32_t BatteryService::GetCapacityLevel(uint32_t& batteryCapacityLevel)
{
BatteryXCollie batteryXCollie("BatteryService::GetCapacityLevel");
batteryCapacityLevel = static_cast<uint32_t>(GetCapacityLevelInner());
return ERR_OK;
}
int32_t BatteryService::GetRemainingChargeTime(int64_t& remainTime)
{
BatteryXCollie batteryXCollie("BatteryService::GetRemainingChargeTime");
remainTime = GetRemainingChargeTimeInner();
return ERR_OK;
}
int32_t BatteryService::SetBatteryConfig(const std::string& sceneName, const std::string& value, int32_t& batteryErr)
{
BatteryXCollie batteryXCollie("BatteryService::SetBatteryConfig");
batteryErr = static_cast<int32_t>(SetBatteryConfigInner(sceneName, value));
return ERR_OK;
}
int32_t BatteryService::GetBatteryConfig(const std::string& sceneName, std::string& result, int32_t& batteryErr)
{
BatteryXCollie batteryXCollie("BatteryService::GetBatteryConfig");
batteryErr = static_cast<int32_t>(GetBatteryConfigInner(sceneName, result));
return ERR_OK;
}
int32_t BatteryService::IsBatteryConfigSupported(const std::string& featureName, bool& result, int32_t& batteryErr)
{
BatteryXCollie batteryXCollie("BatteryService::IsBatteryConfigSupported");
batteryErr = static_cast<int32_t>(IsBatteryConfigSupportedInner(featureName, result));
return ERR_OK;
}
} // namespace PowerMgr
} // namespace OHOS
services/zidl/BUILD.gn
+45 -4
View File
@@ -11,17 +11,57 @@
# See the License for the specific language governing permissions and
# limitations under the License.
import("//build/config/components/idl_tool/idl.gni")
import("../../batterymgr.gni")
config("batterysrv_public_config") {
include_dirs = [
"include",
"${battery_inner_api}/native/include",
"${target_gen_dir}",
]
}
ohos_shared_library("batterysrv_stub") {
sources = [ "${battery_service_zidl}/src/battery_srv_stub.cpp" ]
idl_gen_interface("batterysrv_interface") {
sources = [ "IBatterySrv.idl" ]
log_domainid = "0xD002922"
log_tag = "BatterySvc"
subsystem_name = "powermgr"
part_name = "battery_manager"
}
ohos_source_set("batterysrv_proxy") {
sanitize = {
cfi = true
cfi_cross_dso = true
debug = false
}
output_values = get_target_outputs(":batterysrv_interface")
sources = filter_include(output_values, [ "*_proxy.cpp" ])
configs = [
"${battery_utils}:utils_config",
":batterysrv_public_config",
"${battery_utils}:coverage_flags",
]
deps = [ ":batterysrv_interface" ]
external_deps = [
"c_utils:utils",
"hilog:libhilog",
"ipc:ipc_single",
"samgr:samgr_proxy",
]
subsystem_name = "powermgr"
part_name = "battery_manager"
}
ohos_source_set("batterysrv_stub") {
sanitize = {
cfi = true
cfi_cross_dso = true
debug = false
}
output_values = get_target_outputs(":batterysrv_interface")
sources = filter_include(output_values, [ "*_stub.cpp" ])
configs = [
"${battery_utils}:utils_config",
@@ -29,11 +69,12 @@ ohos_shared_library("batterysrv_stub") {
"${battery_utils}:coverage_flags",
]
deps = [ ":batterysrv_interface" ]
external_deps = [
"c_utils:utils",
"hicollie:libhicollie",
"hilog:libhilog",
"ipc:ipc_core",
"ipc:ipc_single",
]
subsystem_name = "powermgr"
services/zidl/IBatterySrv.idl
+35
View File
@@ -0,0 +1,35 @@
/*
* Copyright 2025 Huawei Device Co., Ltd.
*
* 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.
*/
interface OHOS.PowerMgr.IBatterySrv {
[ipccode 0] void GetCapacity([out] int capacity);
void GetChargingStatus([out] unsigned int chargeState);
void GetHealthStatus([out] unsigned int healthState);
void GetPluggedType([out] unsigned int pluggedType);
void GetVoltage([out] int voltage);
void GetPresent([out] boolean present);
void GetBatteryTemperature([out] int temperature);
void GetTechnology([out] String technology);
void GetCapacityLevel([out] unsigned int batteryCapacityLevel);
void GetRemainingChargeTime([out] long remainTime);
void GetTotalEnergy([out] int totalEnergy);
void GetCurrentAverage([out] int curAverage);
void GetNowCurrent([out] int nowCurr);
void GetRemainEnergy([out] int remainEnergy);
void SetBatteryConfig([in] String sceneName, [in] String value, [out] int batteryErr);
void GetBatteryConfig([in] String sceneName, [out] String getResult, [out] int batteryErr);
void IsBatteryConfigSupported([in] String featureName, [out] boolean isResult, [out] int batteryErr);
}
services/zidl/include/battery_srv_proxy.h
-62
View File
@@ -1,62 +0,0 @@
/*
* Copyright (c) 2021 Huawei Device Co., Ltd.
* 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.
*/
#ifndef BATTERY_SRV_PROXY_H
#define BATTERY_SRV_PROXY_H
#include <cstdint>
#include <functional>
#include <iosfwd>
#include "refbase.h"
#include "nocopyable.h"
#include "iremote_broker.h"
#include "iremote_object.h"
#include "iremote_proxy.h"
#include "ibattery_srv.h"
#include "battery_info.h"
namespace OHOS {
namespace PowerMgr {
class BatterySrvProxy : public IRemoteProxy<IBatterySrv> {
public:
explicit BatterySrvProxy(const sptr<IRemoteObject>& impl)
: IRemoteProxy<IBatterySrv>(impl) {}
~BatterySrvProxy() = default;
DISALLOW_COPY_AND_MOVE(BatterySrvProxy);
virtual int32_t GetCapacity() override;
virtual BatteryChargeState GetChargingStatus() override;
virtual BatteryHealthState GetHealthStatus() override;
virtual BatteryPluggedType GetPluggedType() override;
virtual int32_t GetVoltage() override;
virtual bool GetPresent() override;
virtual std::string GetTechnology() override;
virtual int32_t GetTotalEnergy() override;
virtual int32_t GetCurrentAverage() override;
virtual int32_t GetNowCurrent() override;
virtual int32_t GetRemainEnergy() override;
virtual int32_t GetBatteryTemperature() override;
virtual BatteryCapacityLevel GetCapacityLevel() override;
virtual int64_t GetRemainingChargeTime() override;
virtual BatteryError SetBatteryConfig(const std::string& sceneName, const std::string& value) override;
virtual BatteryError GetBatteryConfig(const std::string& sceneNam, std::string& result) override;
virtual BatteryError IsBatteryConfigSupported(const std::string& sceneName, bool& result) override;
private:
static inline BrokerDelegator<BatterySrvProxy> delegator_;
};
} // namespace PowerMgr
} // namespace OHOS
#endif // BATTERY_SRV_PROXY_H
services/zidl/include/battery_srv_stub.h
-60
View File
@@ -1,60 +0,0 @@
/*
* Copyright (c) 2021 Huawei Device Co., Ltd.
* 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.
*/
#ifndef BATTERY_SRV_STUB_H
#define BATTERY_SRV_STUB_H
#include <cstdint>
#include "refbase.h"
#include "nocopyable.h"
#include "iremote_stub.h"
#include "ibattery_srv.h"
#include "message_option.h"
namespace OHOS {
namespace PowerMgr {
class BatterySrvStub : public IRemoteStub<IBatterySrv> {
public:
DISALLOW_COPY_AND_MOVE(BatterySrvStub);
BatterySrvStub() = default;
virtual ~BatterySrvStub() = default;
int OnRemoteRequest(uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option) override;
private:
int32_t GetCapacityStub(MessageParcel& reply);
int32_t GetChargingStatusStub(MessageParcel& reply);
int32_t GetHealthStatusStub(MessageParcel& reply);
int32_t GetPluggedTypeStub(MessageParcel& reply);
int32_t GetVoltageStub(MessageParcel& reply);
int32_t GetPresentStub(MessageParcel& reply);
int32_t GetTechnologyStub(MessageParcel& reply);
int32_t GetBatteryTemperatureStub(MessageParcel& reply);
int32_t GetBatteryCapacityLevelStub(MessageParcel& reply);
int64_t GetRemainingChargeTimeStub(MessageParcel& reply);
int32_t GetNowCurrentStub(MessageParcel& reply);
int32_t GetRemainEnergyStub(MessageParcel& reply);
int32_t GetTotalEnergyStub(MessageParcel& reply);
int32_t GetCurrentAverageStub(MessageParcel& reply);
int32_t CheckRequestCode(const uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option);
int32_t SetChargeConfigStub(MessageParcel& data, MessageParcel& reply);
int32_t GetChargeConfigStub(MessageParcel& data, MessageParcel& reply);
int32_t SupportChargeConfigStub(MessageParcel& data, MessageParcel& reply);
};
} // namespace PowerMgr
} // namespace OHOS
#endif // BATTERY_SRV_STUB_H
services/zidl/src/battery_srv_proxy.cpp
-469
View File
@@ -1,469 +0,0 @@
/*
* Copyright (c) 2021-2022 Huawei Device Co., Ltd.
* 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 "battery_srv_proxy.h"
#include "errors.h"
#include "message_option.h"
#include "message_parcel.h"
#include "battery_log.h"
#include "battery_manager_ipc_interface_code.h"
#include "power_common.h"
#include "power_mgr_errors.h"
#include "string_ex.h"
namespace OHOS {
namespace PowerMgr {
int32_t BatterySrvProxy::GetCapacity()
{
sptr<IRemoteObject> remote = Remote();
RETURN_IF_WITH_RET(remote == nullptr, INVALID_BATT_INT_VALUE);
MessageParcel data;
MessageParcel reply;
MessageOption option;
if (!data.WriteInterfaceToken(BatterySrvProxy::GetDescriptor())) {
BATTERY_HILOGW(FEATURE_BATT_INFO, "Write descriptor failed");
return INVALID_BATT_INT_VALUE;
}
int ret = remote->SendRequest(
static_cast<int>(PowerMgr::BatterySrvInterfaceCode::BATT_GET_CAPACITY),
data, reply, option);
if (ret != ERR_OK) {
BATTERY_HILOGW(FEATURE_BATT_INFO, "%{public}s: SendRequest failed with ret=%{public}d", __func__, ret);
return INVALID_BATT_INT_VALUE;
}
int32_t capacity = INVALID_BATT_INT_VALUE;
RETURN_IF_READ_PARCEL_FAILED_WITH_RET(reply, Int32, capacity, INVALID_BATT_INT_VALUE);
return capacity;
}
BatteryChargeState BatterySrvProxy::GetChargingStatus()
{
sptr<IRemoteObject> remote = Remote();
RETURN_IF_WITH_RET(remote == nullptr, BatteryChargeState::CHARGE_STATE_BUTT);
MessageParcel data;
MessageParcel reply;
MessageOption option;
if (!data.WriteInterfaceToken(BatterySrvProxy::GetDescriptor())) {
BATTERY_HILOGW(FEATURE_BATT_INFO, "Write descriptor failed");
return BatteryChargeState::CHARGE_STATE_BUTT;
}
int ret = remote->SendRequest(
static_cast<int>(PowerMgr::BatterySrvInterfaceCode::BATT_GET_CHARGING_STATUS),
data, reply, option);
if (ret != ERR_OK) {
BATTERY_HILOGW(FEATURE_BATT_INFO, "%{public}s: SendRequest failed with ret=%{public}d", __func__, ret);
return BatteryChargeState::CHARGE_STATE_BUTT;
}
uint32_t chargingState = static_cast<uint32_t>(BatteryChargeState::CHARGE_STATE_BUTT);
RETURN_IF_READ_PARCEL_FAILED_WITH_RET(reply, Uint32, chargingState, BatteryChargeState::CHARGE_STATE_BUTT);
return static_cast<BatteryChargeState>(chargingState);
}
BatteryHealthState BatterySrvProxy::GetHealthStatus()
{
sptr<IRemoteObject> remote = Remote();
RETURN_IF_WITH_RET(remote == nullptr, BatteryHealthState::HEALTH_STATE_BUTT);
MessageParcel data;
MessageParcel reply;
MessageOption option;
if (!data.WriteInterfaceToken(BatterySrvProxy::GetDescriptor())) {
BATTERY_HILOGW(FEATURE_BATT_INFO, "Write descriptor failed");
return BatteryHealthState::HEALTH_STATE_BUTT;
}
int ret = remote->SendRequest(
static_cast<int>(PowerMgr::BatterySrvInterfaceCode::BATT_GET_HEALTH_STATUS),
data, reply, option);
if (ret != ERR_OK) {
BATTERY_HILOGW(FEATURE_BATT_INFO, "%{public}s: SendRequest failed with ret=%{public}d", __func__, ret);
return BatteryHealthState::HEALTH_STATE_BUTT;
}
uint32_t healthStatus = static_cast<uint32_t>(BatteryHealthState::HEALTH_STATE_BUTT);
RETURN_IF_READ_PARCEL_FAILED_WITH_RET(reply, Uint32, healthStatus, BatteryHealthState::HEALTH_STATE_BUTT);
return static_cast<BatteryHealthState>(healthStatus);
}
BatteryPluggedType BatterySrvProxy::GetPluggedType()
{
sptr<IRemoteObject> remote = Remote();
RETURN_IF_WITH_RET(remote == nullptr, BatteryPluggedType::PLUGGED_TYPE_BUTT);
MessageParcel data;
MessageParcel reply;
MessageOption option;
if (!data.WriteInterfaceToken(BatterySrvProxy::GetDescriptor())) {
BATTERY_HILOGW(FEATURE_BATT_INFO, "Write descriptor failed");
return BatteryPluggedType::PLUGGED_TYPE_BUTT;
}
int ret = remote->SendRequest(
static_cast<int>(PowerMgr::BatterySrvInterfaceCode::BATT_GET_PLUG_TYPE),
data, reply, option);
if (ret != ERR_OK) {
BATTERY_HILOGW(FEATURE_BATT_INFO, "%{public}s: SendRequest failed with ret=%{public}d", __func__, ret);
return BatteryPluggedType::PLUGGED_TYPE_BUTT;
}
uint32_t pluggedType = static_cast<uint32_t>(BatteryPluggedType::PLUGGED_TYPE_BUTT);
RETURN_IF_READ_PARCEL_FAILED_WITH_RET(reply, Uint32, pluggedType, BatteryPluggedType::PLUGGED_TYPE_BUTT);
return static_cast<BatteryPluggedType>(pluggedType);
}
int32_t BatterySrvProxy::GetVoltage()
{
sptr<IRemoteObject> remote = Remote();
RETURN_IF_WITH_RET(remote == nullptr, INVALID_BATT_INT_VALUE);
MessageParcel data;
MessageParcel reply;
MessageOption option;
if (!data.WriteInterfaceToken(BatterySrvProxy::GetDescriptor())) {
BATTERY_HILOGW(FEATURE_BATT_INFO, "Write descriptor failed");
return INVALID_BATT_INT_VALUE;
}
int ret = remote->SendRequest(
static_cast<int>(PowerMgr::BatterySrvInterfaceCode::BATT_GET_VOLTAGE),
data, reply, option);
if (ret != ERR_OK) {
BATTERY_HILOGW(FEATURE_BATT_INFO, "%{public}s: SendRequest failed with ret=%{public}d", __func__, ret);
return INVALID_BATT_INT_VALUE;
}
int32_t voltage = INVALID_BATT_INT_VALUE;
RETURN_IF_READ_PARCEL_FAILED_WITH_RET(reply, Int32, voltage, INVALID_BATT_INT_VALUE);
return voltage;
}
bool BatterySrvProxy::GetPresent()
{
sptr<IRemoteObject> remote = Remote();
RETURN_IF_WITH_RET(remote == nullptr, INVALID_BATT_BOOL_VALUE);
MessageParcel data;
MessageParcel reply;
MessageOption option;
if (!data.WriteInterfaceToken(BatterySrvProxy::GetDescriptor())) {
BATTERY_HILOGW(FEATURE_BATT_INFO, "Write descriptor failed");
return INVALID_BATT_BOOL_VALUE;
}
int ret = remote->SendRequest(
static_cast<int>(PowerMgr::BatterySrvInterfaceCode::BATT_GET_PRESENT),
data, reply, option);
if (ret != ERR_OK) {
BATTERY_HILOGW(FEATURE_BATT_INFO, "%{public}s: SendRequest failed with ret=%{public}d", __func__, ret);
return INVALID_BATT_BOOL_VALUE;
}
bool present = INVALID_BATT_BOOL_VALUE;
RETURN_IF_READ_PARCEL_FAILED_WITH_RET(reply, Bool, present, INVALID_BATT_BOOL_VALUE);
return present;
}
std::string BatterySrvProxy::GetTechnology()
{
sptr<IRemoteObject> remote = Remote();
RETURN_IF_WITH_RET(remote == nullptr, INVALID_STRING_VALUE);
MessageParcel data;
MessageParcel reply;
MessageOption option;
if (!data.WriteInterfaceToken(BatterySrvProxy::GetDescriptor())) {
BATTERY_HILOGW(FEATURE_BATT_INFO, "Write descriptor failed");
return INVALID_STRING_VALUE;
}
int ret = remote->SendRequest(
static_cast<int>(PowerMgr::BatterySrvInterfaceCode::BATT_GET_TECHNOLOGY),
data, reply, option);
if (ret != ERR_OK) {
BATTERY_HILOGW(FEATURE_BATT_INFO, "%{public}s: SendRequest failed with ret=%{public}d", __func__, ret);
return INVALID_STRING_VALUE;
}
std::u16string technology = Str8ToStr16(INVALID_STRING_VALUE);
RETURN_IF_READ_PARCEL_FAILED_WITH_RET(reply, String16, technology, INVALID_STRING_VALUE);
return Str16ToStr8(technology);
}
int32_t BatterySrvProxy::GetBatteryTemperature()
{
sptr<IRemoteObject> remote = Remote();
RETURN_IF_WITH_RET(remote == nullptr, INVALID_BATT_TEMP_VALUE);
MessageParcel data;
MessageParcel reply;
MessageOption option;
if (!data.WriteInterfaceToken(BatterySrvProxy::GetDescriptor())) {
BATTERY_HILOGW(FEATURE_BATT_INFO, "Write descriptor failed");
return INVALID_BATT_TEMP_VALUE;
}
int ret = remote->SendRequest(
static_cast<int>(PowerMgr::BatterySrvInterfaceCode::BATT_GET_TEMPERATURE),
data, reply, option);
if (ret != ERR_OK) {
BATTERY_HILOGW(FEATURE_BATT_INFO, "%{public}s: SendRequest failed with ret=%{public}d", __func__, ret);
return INVALID_BATT_TEMP_VALUE;
}
int32_t temperature = INVALID_BATT_TEMP_VALUE;
RETURN_IF_READ_PARCEL_FAILED_WITH_RET(reply, Int32, temperature, INVALID_BATT_TEMP_VALUE);
return temperature;
}
BatteryCapacityLevel BatterySrvProxy::GetCapacityLevel()
{
sptr<IRemoteObject> remote = Remote();
RETURN_IF_WITH_RET(remote == nullptr, BatteryCapacityLevel::LEVEL_NONE);
MessageParcel data;
MessageParcel reply;
MessageOption option;
if (!data.WriteInterfaceToken(BatterySrvProxy::GetDescriptor())) {
BATTERY_HILOGW(FEATURE_BATT_INFO, "Write descriptor failed");
return BatteryCapacityLevel::LEVEL_NONE;
}
int ret = remote->SendRequest(
static_cast<int>(PowerMgr::BatterySrvInterfaceCode::BATT_GET_BATTERY_LEVEL),
data, reply, option);
if (ret != ERR_OK) {
BATTERY_HILOGW(FEATURE_BATT_INFO, "%{public}s: SendRequest failed with ret=%{public}d", __func__, ret);
return BatteryCapacityLevel::LEVEL_NONE;
}
uint32_t level = static_cast<uint32_t>(BatteryCapacityLevel::LEVEL_NONE);
RETURN_IF_READ_PARCEL_FAILED_WITH_RET(reply, Uint32, level, BatteryCapacityLevel::LEVEL_NONE);
return static_cast<BatteryCapacityLevel>(level);
}
int64_t BatterySrvProxy::GetRemainingChargeTime()
{
sptr<IRemoteObject> remote = Remote();
RETURN_IF_WITH_RET(remote == nullptr, INVALID_REMAINING_CHARGE_TIME_VALUE);
MessageParcel data;
MessageParcel reply;
MessageOption option;
if (!data.WriteInterfaceToken(BatterySrvProxy::GetDescriptor())) {
BATTERY_HILOGW(FEATURE_BATT_INFO, "BatterySrvProxy::%{public}s write descriptor failed!", __func__);
return INVALID_REMAINING_CHARGE_TIME_VALUE;
}
int ret = remote->SendRequest(
static_cast<int>(PowerMgr::BatterySrvInterfaceCode::BATT_GET_REMAINING_CHARGE_TIME),
data, reply, option);
if (ret != ERR_OK) {
BATTERY_HILOGW(FEATURE_BATT_INFO, "BatterySrvProxy::%{public}s SendRequest is failed, error code: %d",
__func__, ret);
return INVALID_REMAINING_CHARGE_TIME_VALUE;
}
int64_t time = INVALID_REMAINING_CHARGE_TIME_VALUE;
RETURN_IF_READ_PARCEL_FAILED_WITH_RET(reply, Int64, time, INVALID_REMAINING_CHARGE_TIME_VALUE);
return time;
}
int32_t BatterySrvProxy::GetTotalEnergy()
{
sptr<IRemoteObject> remote = Remote();
RETURN_IF_WITH_RET(remote == nullptr, INVALID_BATT_INT_VALUE);
MessageParcel data;
MessageParcel reply;
MessageOption option;
if (!data.WriteInterfaceToken(BatterySrvProxy::GetDescriptor())) {
BATTERY_HILOGW(FEATURE_BATT_INFO, "Write descriptor failed");
return INVALID_BATT_INT_VALUE;
}
int ret = remote->SendRequest(
static_cast<int>(PowerMgr::BatterySrvInterfaceCode::BATT_GET_BATTERY_TOTAL_ENERGY),
data, reply, option);
if (ret != ERR_OK) {
BATTERY_HILOGW(FEATURE_BATT_INFO, "%{public}s: SendRequest failed with ret=%{public}d", __func__, ret);
return INVALID_BATT_INT_VALUE;
}
int32_t totalEnergy = INVALID_BATT_INT_VALUE;
RETURN_IF_READ_PARCEL_FAILED_WITH_RET(reply, Int32, totalEnergy, INVALID_BATT_INT_VALUE);
return totalEnergy;
}
int32_t BatterySrvProxy::GetCurrentAverage()
{
sptr<IRemoteObject> remote = Remote();
RETURN_IF_WITH_RET(remote == nullptr, INVALID_BATT_INT_VALUE);
MessageParcel data;
MessageParcel reply;
MessageOption option;
if (!data.WriteInterfaceToken(BatterySrvProxy::GetDescriptor())) {
BATTERY_HILOGW(FEATURE_BATT_INFO, "Write descriptor failed");
return INVALID_BATT_INT_VALUE;
}
int ret = remote->SendRequest(
static_cast<int>(PowerMgr::BatterySrvInterfaceCode::BATT_GET_BATTERY_CURRENT_AVERAGE),
data, reply, option);
if (ret != ERR_OK) {
BATTERY_HILOGW(FEATURE_BATT_INFO, "%{public}s: SendRequest failed with ret=%{public}d", __func__, ret);
return INVALID_BATT_INT_VALUE;
}
int32_t curAverage = INVALID_BATT_INT_VALUE;
RETURN_IF_READ_PARCEL_FAILED_WITH_RET(reply, Int32, curAverage, INVALID_BATT_INT_VALUE);
return curAverage;
}
int32_t BatterySrvProxy::GetNowCurrent()
{
sptr<IRemoteObject> remote = Remote();
RETURN_IF_WITH_RET(remote == nullptr, INVALID_BATT_INT_VALUE);
MessageParcel data;
MessageParcel reply;
MessageOption option;
if (!data.WriteInterfaceToken(BatterySrvProxy::GetDescriptor())) {
BATTERY_HILOGW(FEATURE_BATT_INFO, "Write descriptor failed");
return INVALID_BATT_INT_VALUE;
}
int ret = remote->SendRequest(
static_cast<int>(PowerMgr::BatterySrvInterfaceCode::BATT_GET_BATTERY_CURRENT_NOW),
data, reply, option);
if (ret != ERR_OK) {
BATTERY_HILOGW(FEATURE_BATT_INFO, "%{public}s: SendRequest failed with ret=%{public}d", __func__, ret);
return INVALID_BATT_INT_VALUE;
}
int32_t nowCurr = INVALID_BATT_INT_VALUE;
RETURN_IF_READ_PARCEL_FAILED_WITH_RET(reply, Int32, nowCurr, INVALID_BATT_INT_VALUE);
return nowCurr;
}
int32_t BatterySrvProxy::GetRemainEnergy()
{
sptr<IRemoteObject> remote = Remote();
RETURN_IF_WITH_RET(remote == nullptr, INVALID_BATT_INT_VALUE);
MessageParcel data;
MessageParcel reply;
MessageOption option;
if (!data.WriteInterfaceToken(BatterySrvProxy::GetDescriptor())) {
BATTERY_HILOGW(FEATURE_BATT_INFO, "Write descriptor failed");
return INVALID_BATT_INT_VALUE;
}
int ret = remote->SendRequest(
static_cast<int>(PowerMgr::BatterySrvInterfaceCode::BATT_GET_BATTERY_REMAIN_ENERGY),
data, reply, option);
if (ret != ERR_OK) {
BATTERY_HILOGW(FEATURE_BATT_INFO, "%{public}s: SendRequest failed with ret=%{public}d", __func__, ret);
return INVALID_BATT_INT_VALUE;
}
int32_t remainEnergy = INVALID_BATT_INT_VALUE;
RETURN_IF_READ_PARCEL_FAILED_WITH_RET(reply, Int32, remainEnergy, INVALID_BATT_INT_VALUE);
return remainEnergy;
}
BatteryError BatterySrvProxy::SetBatteryConfig(const std::string& sceneName, const std::string& value)
{
sptr<IRemoteObject> remote = Remote();
RETURN_IF_WITH_RET(remote == nullptr, BatteryError::ERR_CONNECTION_FAIL);
MessageParcel data;
MessageParcel reply;
MessageOption option;
if (!data.WriteInterfaceToken(BatterySrvProxy::GetDescriptor())) {
BATTERY_HILOGW(FEATURE_BATT_INFO, "Write descriptor failed");
return BatteryError::ERR_CONNECTION_FAIL;
}
RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, String16, Str8ToStr16(sceneName), BatteryError::ERR_CONNECTION_FAIL);
RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, String16, Str8ToStr16(value), BatteryError::ERR_CONNECTION_FAIL);
int ret = remote->SendRequest(
static_cast<int>(PowerMgr::BatterySrvInterfaceCode::SET_BATTERY_CONFIG),
data, reply, option);
if (ret != ERR_OK) {
BATTERY_HILOGW(FEATURE_BATT_INFO, "%{public}s: SendRequest failed with ret=%{public}d", __func__, ret);
return BatteryError::ERR_CONNECTION_FAIL;
}
int32_t error;
RETURN_IF_READ_PARCEL_FAILED_WITH_RET(reply, Int32, error, BatteryError::ERR_CONNECTION_FAIL);
return static_cast<BatteryError>(error);
}
BatteryError BatterySrvProxy::GetBatteryConfig(const std::string& sceneName, std::string& result)
{
sptr<IRemoteObject> remote = Remote();
RETURN_IF_WITH_RET(remote == nullptr, BatteryError::ERR_CONNECTION_FAIL);
MessageParcel data;
MessageParcel reply;
MessageOption option;
if (!data.WriteInterfaceToken(BatterySrvProxy::GetDescriptor())) {
BATTERY_HILOGW(FEATURE_BATT_INFO, "Write descriptor failed");
return BatteryError::ERR_CONNECTION_FAIL;
}
RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, String16, Str8ToStr16(sceneName), BatteryError::ERR_CONNECTION_FAIL);
int ret = remote->SendRequest(
static_cast<int>(PowerMgr::BatterySrvInterfaceCode::GET_BATTERY_CONFIG),
data, reply, option);
if (ret != ERR_OK) {
BATTERY_HILOGW(FEATURE_BATT_INFO, "%{public}s: SendRequest failed with ret=%{public}d", __func__, ret);
return BatteryError::ERR_CONNECTION_FAIL;
}
std::u16string tempResult;
int32_t error;
RETURN_IF_READ_PARCEL_FAILED_WITH_RET(reply, Int32, error, BatteryError::ERR_CONNECTION_FAIL);
RETURN_IF_READ_PARCEL_FAILED_WITH_RET(reply, String16, tempResult, BatteryError::ERR_CONNECTION_FAIL);
result = Str16ToStr8(tempResult);
return static_cast<BatteryError>(error);
}
BatteryError BatterySrvProxy::IsBatteryConfigSupported(const std::string& sceneName, bool& result)
{
sptr<IRemoteObject> remote = Remote();
RETURN_IF_WITH_RET(remote == nullptr, BatteryError::ERR_CONNECTION_FAIL);
MessageParcel data;
MessageParcel reply;
MessageOption option;
if (!data.WriteInterfaceToken(BatterySrvProxy::GetDescriptor())) {
BATTERY_HILOGW(FEATURE_BATT_INFO, "Write descriptor failed");
return BatteryError::ERR_CONNECTION_FAIL;
}
RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, String16, Str8ToStr16(sceneName), BatteryError::ERR_CONNECTION_FAIL);
int ret = remote->SendRequest(
static_cast<int>(PowerMgr::BatterySrvInterfaceCode::SUPPORT_BATTERY_CONFIG),
data, reply, option);
if (ret != ERR_OK) {
BATTERY_HILOGW(FEATURE_BATT_INFO, "%{public}s: SendRequest failed with ret=%{public}d", __func__, ret);
return BatteryError::ERR_CONNECTION_FAIL;
}
int32_t error;
RETURN_IF_READ_PARCEL_FAILED_WITH_RET(reply, Int32, error, BatteryError::ERR_CONNECTION_FAIL);
RETURN_IF_READ_PARCEL_FAILED_WITH_RET(reply, Bool, result, BatteryError::ERR_CONNECTION_FAIL);
return static_cast<BatteryError>(error);
}
} // namespace PowerMgr
} // namespace OHOS
services/zidl/src/battery_srv_stub.cpp
-228
View File
@@ -1,228 +0,0 @@
/*
* Copyright (c) 2021-2022 Huawei Device Co., Ltd.
* 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 "battery_srv_stub.h"
#include "errors.h"
#include "xcollie/xcollie.h"
#include "xcollie/xcollie_define.h"
#include "ipc_object_stub.h"
#include "message_parcel.h"
#include "battery_info.h"
#include "battery_log.h"
#include "battery_manager_ipc_interface_code.h"
#include "power_mgr_errors.h"
#include "power_common.h"
#include "string_ex.h"
namespace OHOS {
namespace PowerMgr {
int BatterySrvStub::OnRemoteRequest(uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option)
{
BATTERY_HILOGD(FEATURE_BATT_INFO, "cmd = %{public}d, flags = %{public}d", code, option.GetFlags());
std::u16string descriptor = BatterySrvStub::GetDescriptor();
std::u16string remoteDescriptor = data.ReadInterfaceToken();
if (descriptor != remoteDescriptor) {
BATTERY_HILOGE(FEATURE_BATT_INFO, "Descriptor is not matched");
return E_GET_POWER_SERVICE_FAILED;
}
const int DFX_DELAY_S = 60;
int id = HiviewDFX::XCollie::GetInstance().SetTimer("BatteryManagerCallbackStub", DFX_DELAY_S, nullptr, nullptr,
HiviewDFX::XCOLLIE_FLAG_LOG);
int32_t ret = CheckRequestCode(code, data, reply, option);
HiviewDFX::XCollie::GetInstance().CancelTimer(id);
return ret;
}
int32_t BatterySrvStub::CheckRequestCode(const uint32_t code, MessageParcel& data, MessageParcel& reply,
MessageOption& option)
{
switch (code) {
case static_cast<int>(PowerMgr::BatterySrvInterfaceCode::BATT_GET_CAPACITY):
return GetCapacityStub(reply);
case static_cast<int>(PowerMgr::BatterySrvInterfaceCode::BATT_GET_CHARGING_STATUS):
return GetChargingStatusStub(reply);
case static_cast<int>(PowerMgr::BatterySrvInterfaceCode::BATT_GET_HEALTH_STATUS):
return GetHealthStatusStub(reply);
case static_cast<int>(PowerMgr::BatterySrvInterfaceCode::BATT_GET_PLUG_TYPE):
return GetPluggedTypeStub(reply);
case static_cast<int>(PowerMgr::BatterySrvInterfaceCode::BATT_GET_VOLTAGE):
return GetVoltageStub(reply);
case static_cast<int>(PowerMgr::BatterySrvInterfaceCode::BATT_GET_PRESENT):
return GetPresentStub(reply);
case static_cast<int>(PowerMgr::BatterySrvInterfaceCode::BATT_GET_TEMPERATURE):
return GetBatteryTemperatureStub(reply);
case static_cast<int>(PowerMgr::BatterySrvInterfaceCode::BATT_GET_BATTERY_LEVEL):
return GetBatteryCapacityLevelStub(reply);
case static_cast<int>(PowerMgr::BatterySrvInterfaceCode::BATT_GET_REMAINING_CHARGE_TIME):
return GetRemainingChargeTimeStub(reply);
case static_cast<int>(PowerMgr::BatterySrvInterfaceCode::BATT_GET_TECHNOLOGY):
return GetTechnologyStub(reply);
case static_cast<int>(PowerMgr::BatterySrvInterfaceCode::BATT_GET_BATTERY_CURRENT_NOW):
return GetNowCurrentStub(reply);
case static_cast<int>(PowerMgr::BatterySrvInterfaceCode::BATT_GET_BATTERY_REMAIN_ENERGY):
return GetRemainEnergyStub(reply);
case static_cast<int>(PowerMgr::BatterySrvInterfaceCode::BATT_GET_BATTERY_TOTAL_ENERGY):
return GetTotalEnergyStub(reply);
case static_cast<int>(PowerMgr::BatterySrvInterfaceCode::BATT_GET_BATTERY_CURRENT_AVERAGE):
return GetCurrentAverageStub(reply);
case static_cast<int>(PowerMgr::BatterySrvInterfaceCode::SET_BATTERY_CONFIG):
return SetChargeConfigStub(data, reply);
case static_cast<int>(PowerMgr::BatterySrvInterfaceCode::GET_BATTERY_CONFIG):
return GetChargeConfigStub(data, reply);
case static_cast<int>(PowerMgr::BatterySrvInterfaceCode::SUPPORT_BATTERY_CONFIG):
return SupportChargeConfigStub(data, reply);
default:
return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
}
}
int32_t BatterySrvStub::GetCapacityStub(MessageParcel& reply)
{
int32_t ret = GetCapacity();
RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(reply, Int32, ret, E_WRITE_PARCEL_ERROR);
return ERR_OK;
}
int32_t BatterySrvStub::GetChargingStatusStub(MessageParcel& reply)
{
BatteryChargeState ret = GetChargingStatus();
RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(reply, Uint32, static_cast<uint32_t>(ret), E_WRITE_PARCEL_ERROR);
return ERR_OK;
}
int32_t BatterySrvStub::GetHealthStatusStub(MessageParcel& reply)
{
BatteryHealthState ret = GetHealthStatus();
RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(reply, Uint32, static_cast<uint32_t>(ret), E_WRITE_PARCEL_ERROR);
return ERR_OK;
}
int32_t BatterySrvStub::GetPluggedTypeStub(MessageParcel& reply)
{
BatteryPluggedType ret = GetPluggedType();
RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(reply, Uint32, static_cast<uint32_t>(ret), E_WRITE_PARCEL_ERROR);
return ERR_OK;
}
int32_t BatterySrvStub::GetVoltageStub(MessageParcel& reply)
{
int32_t ret = GetVoltage();
RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(reply, Int32, ret, E_WRITE_PARCEL_ERROR);
return ERR_OK;
}
int32_t BatterySrvStub::GetPresentStub(MessageParcel& reply)
{
bool ret = GetPresent();
RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(reply, Bool, ret, E_WRITE_PARCEL_ERROR);
return ERR_OK;
}
int32_t BatterySrvStub::GetTechnologyStub(MessageParcel& reply)
{
std::u16string ret = Str8ToStr16(GetTechnology());
RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(reply, String16, ret, E_WRITE_PARCEL_ERROR);
return ERR_OK;
}
int32_t BatterySrvStub::GetBatteryTemperatureStub(MessageParcel& reply)
{
int32_t ret = GetBatteryTemperature();
RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(reply, Int32, ret, E_WRITE_PARCEL_ERROR);
return ERR_OK;
}
int32_t BatterySrvStub::GetBatteryCapacityLevelStub(MessageParcel& reply)
{
BatteryCapacityLevel ret = GetCapacityLevel();
RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(reply, Uint32, static_cast<uint32_t>(ret), E_WRITE_PARCEL_ERROR);
return ERR_OK;
}
int64_t BatterySrvStub::GetRemainingChargeTimeStub(MessageParcel& reply)
{
int64_t ret = GetRemainingChargeTime();
RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(reply, Int64, ret, E_WRITE_PARCEL_ERROR);
return ERR_OK;
}
int32_t BatterySrvStub::GetNowCurrentStub(MessageParcel& reply)
{
int32_t ret = GetNowCurrent();
RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(reply, Int32, ret, E_WRITE_PARCEL_ERROR);
return ERR_OK;
}
int32_t BatterySrvStub::GetRemainEnergyStub(MessageParcel& reply)
{
int32_t ret = GetRemainEnergy();
RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(reply, Int32, ret, E_WRITE_PARCEL_ERROR);
return ERR_OK;
}
int32_t BatterySrvStub::GetTotalEnergyStub(MessageParcel& reply)
{
int32_t ret = GetTotalEnergy();
RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(reply, Int32, ret, E_WRITE_PARCEL_ERROR);
return ERR_OK;
}
int32_t BatterySrvStub::GetCurrentAverageStub(MessageParcel& reply)
{
int32_t ret = GetCurrentAverage();
RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(reply, Int32, ret, E_WRITE_PARCEL_ERROR);
return ERR_OK;
}
int32_t BatterySrvStub::SetChargeConfigStub(MessageParcel& data, MessageParcel& reply)
{
std::u16string sceneName;
RETURN_IF_READ_PARCEL_FAILED_WITH_RET(data, String16, sceneName, E_READ_PARCEL_ERROR);
std::string tempSceneName = Str16ToStr8(sceneName);
std::u16string value;
RETURN_IF_READ_PARCEL_FAILED_WITH_RET(data, String16, value, E_READ_PARCEL_ERROR);
std::string tempValue = Str16ToStr8(value);
BatteryError error = SetBatteryConfig(tempSceneName, tempValue);
RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(reply, Int32, static_cast<int32_t>(error), E_WRITE_PARCEL_ERROR);
return ERR_OK;
}
int32_t BatterySrvStub::GetChargeConfigStub(MessageParcel& data, MessageParcel& reply)
{
std::u16string sceneName;
RETURN_IF_READ_PARCEL_FAILED_WITH_RET(data, String16, sceneName, E_READ_PARCEL_ERROR);
std::string tempSceneName = Str16ToStr8(sceneName);
std::string result;
BatteryError error = GetBatteryConfig(tempSceneName, result);
RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(reply, Int32, static_cast<int32_t>(error), E_WRITE_PARCEL_ERROR);
RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(reply, String16, Str8ToStr16(result), E_WRITE_PARCEL_ERROR);
return ERR_OK;
}
int32_t BatterySrvStub::SupportChargeConfigStub(MessageParcel& data, MessageParcel& reply)
{
std::u16string sceneName;
RETURN_IF_READ_PARCEL_FAILED_WITH_RET(data, String16, sceneName, E_READ_PARCEL_ERROR);
std::string tempSceneName = Str16ToStr8(sceneName);
bool result = false;
BatteryError error = IsBatteryConfigSupported(tempSceneName, result);
RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(reply, Int32, static_cast<int32_t>(error), E_WRITE_PARCEL_ERROR);
RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(reply, Bool, result, E_WRITE_PARCEL_ERROR);
return ERR_OK;
}
} // namespace PowerMgr
} // namespace OHOS
test/benchmarktest/BUILD.gn
+2
View File
@@ -25,6 +25,8 @@ ohos_benchmarktest("BatteryBenchmarkTest") {
"ipc:ipc_core",
]
external_deps += [ "hilog:libhilog" ]
cflags = [
"-Wall",
"-Wextra",
test/fuzztest/getbatteryconfig_fuzzer/getbatteryconfig_fuzzer_test.cpp
+2 -2
View File
@@ -18,7 +18,7 @@
#define FUZZ_PROJECT_NAME "getbatteryconfig_fuzzer"
#include "battery_fuzzer_test.h"
#include "battery_manager_ipc_interface_code.h"
#include "ibattery_srv.h"
using namespace OHOS::PowerMgr;
@@ -31,6 +31,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
{
/* Run your code on data */
g_serviceTest.TestBatteryServiceStub(
static_cast<uint32_t>(BatterySrvInterfaceCode::GET_BATTERY_CONFIG), data, size);
static_cast<uint32_t>(IBatterySrvIpcCode::COMMAND_GET_BATTERY_CONFIG), data, size);
return 0;
}
test/fuzztest/getbatterytemperature_fuzzer/getbatterytemperature_fuzzer_test.cpp
+2 -2
View File
@@ -18,7 +18,7 @@
#define FUZZ_PROJECT_NAME "getbatterytemperature_fuzzer"
#include "battery_fuzzer_test.h"
#include "battery_manager_ipc_interface_code.h"
#include "ibattery_srv.h"
using namespace OHOS::PowerMgr;
@@ -31,6 +31,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
{
/* Run your code on data */
g_serviceTest.TestBatteryServiceStub(
static_cast<uint32_t>(BatterySrvInterfaceCode::BATT_GET_TEMPERATURE), data, size);
static_cast<uint32_t>(IBatterySrvIpcCode::COMMAND_GET_BATTERY_TEMPERATURE), data, size);
return 0;
}
test/fuzztest/getcapacity_fuzzer/getcapacity_fuzzer_test.cpp
+3 -2
View File
@@ -18,7 +18,7 @@
#define FUZZ_PROJECT_NAME "getcapacity_fuzzer"
#include "battery_fuzzer_test.h"
#include "battery_manager_ipc_interface_code.h"
#include "ibattery_srv.h"
using namespace OHOS::PowerMgr;
@@ -30,6 +30,7 @@ BatteryFuzzerTest g_serviceTest;
extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
{
/* Run your code on data */
g_serviceTest.TestBatteryServiceStub(static_cast<uint32_t>(BatterySrvInterfaceCode::BATT_GET_CAPACITY), data, size);
g_serviceTest.TestBatteryServiceStub(
static_cast<uint32_t>(IBatterySrvIpcCode::COMMAND_GET_CAPACITY), data, size);
return 0;
}
test/fuzztest/getcapacitylevel_fuzzer/getcapacitylevel_fuzzer_test.cpp
+2 -2
View File
@@ -18,7 +18,7 @@
#define FUZZ_PROJECT_NAME "getcapacitylevel_fuzzer"
#include "battery_fuzzer_test.h"
#include "battery_manager_ipc_interface_code.h"
#include "ibattery_srv.h"
using namespace OHOS::PowerMgr;
@@ -31,6 +31,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
{
/* Run your code on data */
g_serviceTest.TestBatteryServiceStub(
static_cast<uint32_t>(BatterySrvInterfaceCode::BATT_GET_BATTERY_LEVEL), data, size);
static_cast<uint32_t>(IBatterySrvIpcCode::COMMAND_GET_CAPACITY_LEVEL), data, size);
return 0;
}
test/fuzztest/getchargingstatus_fuzzer/getchargingstatus_fuzzer_test.cpp
+2 -2
View File
@@ -18,7 +18,7 @@
#define FUZZ_PROJECT_NAME "getchargingstatus_fuzzer"
#include "battery_fuzzer_test.h"
#include "battery_manager_ipc_interface_code.h"
#include "ibattery_srv.h"
using namespace OHOS::PowerMgr;
@@ -31,6 +31,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
{
/* Run your code on data */
g_serviceTest.TestBatteryServiceStub(
static_cast<uint32_t>(BatterySrvInterfaceCode::BATT_GET_CHARGING_STATUS), data, size);
static_cast<uint32_t>(IBatterySrvIpcCode::COMMAND_GET_CHARGING_STATUS), data, size);
return 0;
}
test/fuzztest/getcurrentaverage_fuzzer/getcurrentaverage_fuzzer_test.cpp
+2 -2
View File
@@ -18,7 +18,7 @@
#define FUZZ_PROJECT_NAME "getcurrentaverage_fuzzer"
#include "battery_fuzzer_test.h"
#include "battery_manager_ipc_interface_code.h"
#include "ibattery_srv.h"
using namespace OHOS::PowerMgr;
@@ -31,6 +31,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
{
/* Run your code on data */
g_serviceTest.TestBatteryServiceStub(
static_cast<uint32_t>(BatterySrvInterfaceCode::BATT_GET_BATTERY_CURRENT_AVERAGE), data, size);
static_cast<uint32_t>(IBatterySrvIpcCode::COMMAND_GET_CURRENT_AVERAGE), data, size);
return 0;
}
test/fuzztest/gethealthstatus_fuzzer/gethealthstatus_fuzzer_test.cpp
+2 -2
View File
@@ -18,7 +18,7 @@
#define FUZZ_PROJECT_NAME "gethealthstatus_fuzzer"
#include "battery_fuzzer_test.h"
#include "battery_manager_ipc_interface_code.h"
#include "ibattery_srv.h"
using namespace OHOS::PowerMgr;
@@ -31,6 +31,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
{
/* Run your code on data */
g_serviceTest.TestBatteryServiceStub(
static_cast<uint32_t>(BatterySrvInterfaceCode::BATT_GET_HEALTH_STATUS), data, size);
static_cast<uint32_t>(IBatterySrvIpcCode::COMMAND_GET_HEALTH_STATUS), data, size);
return 0;
}
test/fuzztest/getnowcurrent_fuzzer/getnowcurrent_fuzzer_test.cpp
+2 -2
View File
@@ -18,7 +18,7 @@
#define FUZZ_PROJECT_NAME "getnowcurrent_fuzzer"
#include "battery_fuzzer_test.h"
#include "battery_manager_ipc_interface_code.h"
#include "ibattery_srv.h"
using namespace OHOS::PowerMgr;
@@ -31,6 +31,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
{
/* Run your code on data */
g_serviceTest.TestBatteryServiceStub(
static_cast<uint32_t>(BatterySrvInterfaceCode::BATT_GET_BATTERY_CURRENT_NOW), data, size);
static_cast<uint32_t>(IBatterySrvIpcCode::COMMAND_GET_NOW_CURRENT), data, size);
return 0;
}
test/fuzztest/getpluggedtype_fuzzer/getpluggedtype_fuzzer_test.cpp
+2 -2
View File
@@ -18,7 +18,7 @@
#define FUZZ_PROJECT_NAME "getpluggedtype_fuzzer"
#include "battery_fuzzer_test.h"
#include "battery_manager_ipc_interface_code.h"
#include "ibattery_srv.h"
using namespace OHOS::PowerMgr;
@@ -31,6 +31,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
{
/* Run your code on data */
g_serviceTest.TestBatteryServiceStub(
static_cast<uint32_t>(BatterySrvInterfaceCode::BATT_GET_PLUG_TYPE), data, size);
static_cast<uint32_t>(IBatterySrvIpcCode::COMMAND_GET_PLUGGED_TYPE), data, size);
return 0;
}
test/fuzztest/getpresent_fuzzer/getpresent_fuzzer_test.cpp
+3 -2
View File
@@ -18,7 +18,7 @@
#define FUZZ_PROJECT_NAME "getpresent_fuzzer"
#include "battery_fuzzer_test.h"
#include "battery_manager_ipc_interface_code.h"
#include "ibattery_srv.h"
using namespace OHOS::PowerMgr;
@@ -30,6 +30,7 @@ BatteryFuzzerTest g_serviceTest;
extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
{
/* Run your code on data */
g_serviceTest.TestBatteryServiceStub(static_cast<uint32_t>(BatterySrvInterfaceCode::BATT_GET_PRESENT), data, size);
g_serviceTest.TestBatteryServiceStub(
static_cast<uint32_t>(IBatterySrvIpcCode::COMMAND_GET_PRESENT), data, size);
return 0;
}
test/fuzztest/getremainenergy_fuzzer/getremainenergy_fuzzer_test.cpp
+2 -2
View File
@@ -18,7 +18,7 @@
#define FUZZ_PROJECT_NAME "getremainenergy_fuzzer"
#include "battery_fuzzer_test.h"
#include "battery_manager_ipc_interface_code.h"
#include "ibattery_srv.h"
using namespace OHOS::PowerMgr;
@@ -31,6 +31,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
{
/* Run your code on data */
g_serviceTest.TestBatteryServiceStub(
static_cast<uint32_t>(BatterySrvInterfaceCode::BATT_GET_BATTERY_REMAIN_ENERGY), data, size);
static_cast<uint32_t>(IBatterySrvIpcCode::COMMAND_GET_REMAIN_ENERGY), data, size);
return 0;
}
test/fuzztest/getremainingchargetime_fuzzer/getremainingchargetime_fuzzer_test.cpp
+2 -2
View File
@@ -18,7 +18,7 @@
#define FUZZ_PROJECT_NAME "getremainingchargetime_fuzzer"
#include "battery_fuzzer_test.h"
#include "battery_manager_ipc_interface_code.h"
#include "ibattery_srv.h"
using namespace OHOS::PowerMgr;
@@ -31,6 +31,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
{
/* Run your code on data */
g_serviceTest.TestBatteryServiceStub(
static_cast<uint32_t>(BatterySrvInterfaceCode::BATT_GET_REMAINING_CHARGE_TIME), data, size);
static_cast<uint32_t>(IBatterySrvIpcCode::COMMAND_GET_REMAINING_CHARGE_TIME), data, size);
return 0;
}
test/fuzztest/gettechnology_fuzzer/gettechnology_fuzzer_test.cpp
+2 -2
View File
@@ -18,7 +18,7 @@
#define FUZZ_PROJECT_NAME "gettechnology_fuzzer"
#include "battery_fuzzer_test.h"
#include "battery_manager_ipc_interface_code.h"
#include "ibattery_srv.h"
using namespace OHOS::PowerMgr;
@@ -31,6 +31,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
{
/* Run your code on data */
g_serviceTest.TestBatteryServiceStub(
static_cast<uint32_t>(BatterySrvInterfaceCode::BATT_GET_TECHNOLOGY), data, size);
static_cast<uint32_t>(IBatterySrvIpcCode::COMMAND_GET_TECHNOLOGY), data, size);
return 0;
}
test/fuzztest/gettotalenergy_fuzzer/gettotalenergy_fuzzer_test.cpp
+2 -2
View File
@@ -18,7 +18,7 @@
#define FUZZ_PROJECT_NAME "gettotalenergy_fuzzer"
#include "battery_fuzzer_test.h"
#include "battery_manager_ipc_interface_code.h"
#include "ibattery_srv.h"
using namespace OHOS::PowerMgr;
@@ -31,6 +31,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
{
/* Run your code on data */
g_serviceTest.TestBatteryServiceStub(
static_cast<uint32_t>(BatterySrvInterfaceCode::BATT_GET_BATTERY_TOTAL_ENERGY), data, size);
static_cast<uint32_t>(IBatterySrvIpcCode::COMMAND_GET_TOTAL_ENERGY), data, size);
return 0;
}
test/fuzztest/getvoltage_fuzzer/getvoltage_fuzzer_test.cpp
+3 -2
View File
@@ -18,7 +18,7 @@
#define FUZZ_PROJECT_NAME "getvoltage_fuzzer"
#include "battery_fuzzer_test.h"
#include "battery_manager_ipc_interface_code.h"
#include "ibattery_srv.h"
using namespace OHOS::PowerMgr;
@@ -30,6 +30,7 @@ BatteryFuzzerTest g_serviceTest;
extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
{
/* Run your code on data */
g_serviceTest.TestBatteryServiceStub(static_cast<uint32_t>(BatterySrvInterfaceCode::BATT_GET_VOLTAGE), data, size);
g_serviceTest.TestBatteryServiceStub(
static_cast<uint32_t>(IBatterySrvIpcCode::COMMAND_GET_VOLTAGE), data, size);
return 0;
}
test/fuzztest/isbatteryconfigsupported_fuzzer/isbatteryconfigsupported_fuzzer_test.cpp
+2 -2
View File
@@ -18,7 +18,7 @@
#define FUZZ_PROJECT_NAME "isbatteryconfigsupported_fuzzer"
#include "battery_fuzzer_test.h"
#include "battery_manager_ipc_interface_code.h"
#include "ibattery_srv.h"
using namespace OHOS::PowerMgr;
@@ -31,6 +31,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
{
/* Run your code on data */
g_serviceTest.TestBatteryServiceStub(
static_cast<uint32_t>(BatterySrvInterfaceCode::SUPPORT_BATTERY_CONFIG), data, size);
static_cast<uint32_t>(IBatterySrvIpcCode::COMMAND_IS_BATTERY_CONFIG_SUPPORTED), data, size);
return 0;
}
test/fuzztest/setbatteryconfig_fuzzer/setbatteryconfig_fuzzer_test.cpp
+2 -2
View File
@@ -18,7 +18,7 @@
#define FUZZ_PROJECT_NAME "setbatteryconfig_fuzzer"
#include "battery_fuzzer_test.h"
#include "battery_manager_ipc_interface_code.h"
#include "ibattery_srv.h"
using namespace OHOS::PowerMgr;
@@ -31,6 +31,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
{
/* Run your code on data */
g_serviceTest.TestBatteryServiceStub(
static_cast<uint32_t>(BatterySrvInterfaceCode::SET_BATTERY_CONFIG), data, size);
static_cast<uint32_t>(IBatterySrvIpcCode::COMMAND_SET_BATTERY_CONFIG), data, size);
return 0;
}
test/unittest/BUILD.gn
+46 -10
View File
@@ -22,7 +22,6 @@ config("module_private_config") {
"include/scenario_test",
"${battery_service_native}/include",
"${battery_service_native}/notification/include",
"${battery_service_zidl}/include",
"${battery_inner_api}/native/include",
"${battery_manager_path}/test/utils",
]
@@ -35,11 +34,11 @@ config("module_private_config_without_json") {
"include/scenario_test",
"${battery_service_native}/include",
"${battery_service_native}/notification/include",
"${battery_service_zidl}/include",
"${battery_inner_api}/native/include",
"${battery_manager_path}/test/utils",
"${battery_manager_path}/charger/include",
"${battery_manager_path}/charger/include/dev",
"${battery_utils}/native/include",
]
}
@@ -54,6 +53,7 @@ ohos_unittest("test_battery_service_interface") {
sources = [
"${battery_manager_path}/test/utils/test_utils.cpp",
"${battery_utils}/native/src/battery_xcollie.cpp",
"src/interface_test/battery_info_test.cpp",
"src/interface_test/battery_service_test.cpp",
]
@@ -82,6 +82,7 @@ ohos_unittest("test_battery_service_interface") {
"drivers_interface_battery:libbattery_proxy_2.0",
"googletest:gtest_main",
"hdf_core:libhdi",
"hicollie:libhicollie",
"hilog:libhilog",
"ipc:ipc_single",
"safwk:system_ability_fwk",
@@ -348,12 +349,17 @@ ohos_unittest("test_battery_stub") {
}
}
### test exceptions when Remote() return nullptr
# test exceptions when Remote() return nullptr
ohos_unittest("test_battery_proxy_mock_iremoteobject") {
sanitize = {
cfi = true
cfi_cross_dso = true
debug = false
}
module_out_path = "${module_output_path}"
sources = [
"${battery_service}/zidl/src/battery_srv_proxy.cpp",
"mock/source/mock_peer_holder.cpp",
"src/battery_srv_proxy_mock_test.cpp",
]
@@ -361,10 +367,13 @@ ohos_unittest("test_battery_proxy_mock_iremoteobject") {
configs = [
":module_mock_private_config",
":module_private_config",
"${battery_service_zidl}:batterysrv_public_config",
"${battery_utils}:utils_config",
"${battery_utils}:coverage_flags",
]
deps = [ "${battery_service_zidl}:batterysrv_proxy" ]
external_deps = [
"ability_base:base",
"ability_base:want",
@@ -383,12 +392,17 @@ ohos_unittest("test_battery_proxy_mock_iremoteobject") {
}
}
### test exceptions when MessageParcel::WriteInterfaceToken() return false
# test exceptions when MessageParcel::WriteInterfaceToken() return false
ohos_unittest("test_battery_proxy_mock_messageparcel_write_error") {
sanitize = {
cfi = true
cfi_cross_dso = true
debug = false
}
module_out_path = "${module_output_path}"
sources = [
"${battery_service}/zidl/src/battery_srv_proxy.cpp",
"mock/source/mock_message_parcel.cpp",
"src/battery_srv_proxy_mock_test.cpp",
]
@@ -396,10 +410,13 @@ ohos_unittest("test_battery_proxy_mock_messageparcel_write_error") {
configs = [
":module_mock_private_config",
":module_private_config",
"${battery_service_zidl}:batterysrv_public_config",
"${battery_utils}:utils_config",
"${battery_utils}:coverage_flags",
]
deps = [ "${battery_service_zidl}:batterysrv_proxy" ]
external_deps = [
"ability_base:base",
"ability_base:want",
@@ -418,13 +435,18 @@ ohos_unittest("test_battery_proxy_mock_messageparcel_write_error") {
}
}
### test exceptions when SendRequest() return value not equal ERR_OK
# test exceptions when SendRequest() return value not equal ERR_OK
ohos_unittest("test_battery_proxy_mock_sendrequest_error") {
sanitize = {
cfi = true
cfi_cross_dso = true
debug = false
}
module_out_path = "${module_output_path}"
defines += [ "ENABLE_REMOTE_INTERFACE" ]
sources = [
"${battery_service}/zidl/src/battery_srv_proxy.cpp",
"mock/source/mock_remote_object.cpp",
"src/battery_srv_proxy_mock_test.cpp",
]
@@ -432,10 +454,13 @@ ohos_unittest("test_battery_proxy_mock_sendrequest_error") {
configs = [
":module_mock_private_config",
":module_private_config",
"${battery_service_zidl}:batterysrv_public_config",
"${battery_utils}:utils_config",
"${battery_utils}:coverage_flags",
]
deps = [ "${battery_service_zidl}:batterysrv_proxy" ]
external_deps = [
"ability_base:base",
"ability_base:want",
@@ -454,12 +479,17 @@ ohos_unittest("test_battery_proxy_mock_sendrequest_error") {
}
}
### test exceptions when read reply MessageParcel error
# test exceptions when read reply MessageParcel error
ohos_unittest("test_battery_proxy_mock_parcel_read_error") {
sanitize = {
cfi = true
cfi_cross_dso = true
debug = false
}
module_out_path = "${module_output_path}"
sources = [
"${battery_service}/zidl/src/battery_srv_proxy.cpp",
"mock/source/mock_parcel.cpp",
"src/battery_srv_proxy_mock_test.cpp",
]
@@ -467,10 +497,13 @@ ohos_unittest("test_battery_proxy_mock_parcel_read_error") {
configs = [
":module_mock_private_config",
":module_private_config",
"${battery_service_zidl}:batterysrv_public_config",
"${battery_utils}:utils_config",
"${battery_utils}:coverage_flags",
]
deps = [ "${battery_service_zidl}:batterysrv_proxy" ]
external_deps = [
"ability_base:base",
"ability_base:want",
@@ -556,11 +589,14 @@ ohos_unittest("test_batteryclient") {
sources = [
"${battery_manager_path}/test/utils/test_utils.cpp",
"mock/source/mock_battery_srv_proxy.cpp",
"mock/source/mock_remote_object.cpp",
"src/interface_test/battery_client_test.cpp",
]
configs = [
"${battery_utils}:utils_config",
":module_mock_private_config",
":module_private_config",
"${battery_utils}:coverage_flags",
]
test/unittest/mock/include/mock_battery_srv_proxy.h
+49
View File
@@ -0,0 +1,49 @@
/*
* Copyright (C) 2025 Huawei Device Co., Ltd.
* 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.
*/
#ifndef MOCK_BATTERY_SRV_PROXY_H
#define MOCK_BATTERY_SRV_PROXY_H
#include "battery_srv_proxy.h"
namespace OHOS {
namespace PowerMgr {
class MockBatterySrvProxy : public BatterySrvProxy {
public:
explicit MockBatterySrvProxy(const sptr<IRemoteObject>& remote)
: BatterySrvProxy(remote)
{}
~MockBatterySrvProxy() {};
int32_t GetCapacity(int32_t& capacity) override;
int32_t GetChargingStatus(uint32_t& chargeState) override;
int32_t GetHealthStatus(uint32_t& healthState) override;
int32_t GetPluggedType(uint32_t& pluggedType) override;
int32_t GetVoltage(int32_t& voltage) override;
int32_t GetPresent(bool& present) override;
int32_t GetTechnology(std::string& technology) override;
int32_t GetTotalEnergy(int32_t& totalEnergy) override;
int32_t GetCurrentAverage(int32_t& curAverage) override;
int32_t GetNowCurrent(int32_t& nowCurr) override;
int32_t GetRemainEnergy(int32_t& remainEnergy) override;
int32_t GetBatteryTemperature(int32_t& temperature) override;
int32_t GetCapacityLevel(uint32_t& batteryCapacityLevel) override;
int32_t GetRemainingChargeTime(int64_t& remainTime) override;
int32_t SetBatteryConfig(const std::string& sceneName, const std::string& value, int32_t& batteryErr) override;
int32_t GetBatteryConfig(const std::string& sceneName, std::string& getResult, int32_t& batteryErr) override;
int32_t IsBatteryConfigSupported(const std::string& featureName, bool& isResult, int32_t& batteryErr) override;
};
} // namespace PowerMgr
} // namespace OHOS
#endif // MOCK_BATTERY_SRV_PROXY_H
test/unittest/mock/source/mock_battery_srv_proxy.cpp
+110
View File
@@ -0,0 +1,110 @@
/*
* Copyright (C) 2025 Huawei Device Co., Ltd.
* 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 "mock_battery_srv_proxy.h"
namespace {
constexpr int32_t ERR_FAIL = -1;
}
namespace OHOS {
namespace PowerMgr {
int32_t MockBatterySrvProxy::GetCapacity(int32_t& capacity)
{
return ERR_FAIL;
}
int32_t MockBatterySrvProxy::GetChargingStatus(uint32_t& chargeState)
{
return ERR_FAIL;
}
int32_t MockBatterySrvProxy::GetHealthStatus(uint32_t& healthState)
{
return ERR_FAIL;
}
int32_t MockBatterySrvProxy::GetPluggedType(uint32_t& pluggedType)
{
return ERR_FAIL;
}
int32_t MockBatterySrvProxy::GetVoltage(int32_t& voltage)
{
return ERR_FAIL;
}
int32_t MockBatterySrvProxy::GetPresent(bool& present)
{
return ERR_FAIL;
}
int32_t MockBatterySrvProxy::GetTechnology(std::string& technology)
{
return ERR_FAIL;
}
int32_t MockBatterySrvProxy::GetTotalEnergy(int32_t& totalEnergy)
{
return ERR_FAIL;
}
int32_t MockBatterySrvProxy::GetCurrentAverage(int32_t& curAverage)
{
return ERR_FAIL;
}
int32_t MockBatterySrvProxy::GetNowCurrent(int32_t& nowCurr)
{
return ERR_FAIL;
}
int32_t MockBatterySrvProxy::GetRemainEnergy(int32_t& remainEnergy)
{
return ERR_FAIL;
}
int32_t MockBatterySrvProxy::GetBatteryTemperature(int32_t& temperature)
{
return ERR_FAIL;
}
int32_t MockBatterySrvProxy::GetCapacityLevel(uint32_t& batteryCapacityLevel)
{
return ERR_FAIL;
}
int32_t MockBatterySrvProxy::GetRemainingChargeTime(int64_t& remainTime)
{
return ERR_FAIL;
}
int32_t MockBatterySrvProxy::SetBatteryConfig(const std::string& sceneName, const std::string& value,
int32_t& batteryErr)
{
return ERR_FAIL;
}
int32_t MockBatterySrvProxy::GetBatteryConfig(const std::string& sceneName, std::string& getResult,
int32_t& batteryErr)
{
return ERR_FAIL;
}
int32_t MockBatterySrvProxy::IsBatteryConfigSupported(const std::string& featureName, bool& isResult,
int32_t& batteryErr)
{
return ERR_FAIL;
}
} // namespace PowerMgr
} // namespace OHOS
test/unittest/src/battert_service_inner_test.cpp
+18
View File
@@ -578,5 +578,23 @@ static HWTEST_F(BatteryDumpTest, BatteryDump016, TestSize.Level1)
EXPECT_EQ(g_service->Dump(fd, args), ERR_NO_INIT);
BATTERY_HILOGI(LABEL_TEST, "BatteryDump016 function end!");
}
/**
* @tc.name: BatteryDump017
* @tc.desc: Get battery information
* @tc.type: FUNC
* @tc.require:
*/
HWTEST_F(BatteryDumpTest, BatteryDump017, TestSize.Level1)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryDump017 begin");
BatteryDump& batteryDump = BatteryDump::GetInstance();
int32_t fd = 1;
std::vector<std::u16string> args;
std::u16string arg = u"-i";
args.push_back(arg);
EXPECT_TRUE(batteryDump.GetBatteryInfo(fd, g_service, args));
BATTERY_HILOGI(LABEL_TEST, "BatteryDump017 end");
}
} // namespace PowerMgr
} // namespace OHOS
test/unittest/src/battery_srv_proxy_mock_test.cpp
+48 -14
View File
@@ -18,6 +18,7 @@
#include "ipc_object_stub.h"
#include "mock_remote_object.h"
#include "battery_log.h"
#include "battery_info.h"
#ifdef HAS_HIVIEWDFX_HISYSEVENT_PART
#include <hisysevent.h>
#endif
@@ -32,6 +33,7 @@ using namespace std;
namespace {
std::shared_ptr<BatterySrvProxy> g_proxy;
sptr<IRemoteObject> remoteObj;
constexpr int32_t INVALID_VALUE = -1;
}
void BatteryProxyMockTest::SetUpTestCase()
@@ -64,7 +66,9 @@ namespace {
HWTEST_F(BatteryProxyMockTest, BatteryProxyMockTest_001, TestSize.Level0)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_001 function start!");
int32_t capacity = g_proxy->GetCapacity();
int32_t capacity = INVALID_BATT_INT_VALUE;
int32_t errCode = g_proxy->GetCapacity(capacity);
EXPECT_TRUE(errCode == INVALID_VALUE || errCode == ERR_INVALID_VALUE || errCode == ERR_INVALID_DATA);
EXPECT_TRUE(capacity == INVALID_BATT_INT_VALUE);
BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_001 function end!");
}
@@ -78,7 +82,10 @@ HWTEST_F(BatteryProxyMockTest, BatteryProxyMockTest_001, TestSize.Level0)
HWTEST_F(BatteryProxyMockTest, BatteryProxyMockTest_002, TestSize.Level0)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_002 function start!");
BatteryChargeState chargeState = g_proxy->GetChargingStatus();
uint32_t chargeStateValue = static_cast<uint32_t>(BatteryChargeState::CHARGE_STATE_NONE);
int32_t errCode = g_proxy->GetChargingStatus(chargeStateValue);
EXPECT_TRUE(errCode == INVALID_VALUE || errCode == ERR_INVALID_VALUE || errCode == ERR_INVALID_DATA);
BatteryChargeState chargeState = static_cast<BatteryChargeState>(chargeStateValue);
EXPECT_TRUE(chargeState >= BatteryChargeState::CHARGE_STATE_NONE &&
chargeState <= BatteryChargeState::CHARGE_STATE_BUTT); // the enum value range of BatteryChargeState
BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_002 function end!");
@@ -93,7 +100,10 @@ HWTEST_F(BatteryProxyMockTest, BatteryProxyMockTest_002, TestSize.Level0)
HWTEST_F(BatteryProxyMockTest, BatteryProxyMockTest_003, TestSize.Level0)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_003 function start!");
BatteryHealthState healthState = g_proxy->GetHealthStatus();
uint32_t healthStateValue = static_cast<uint32_t>(BatteryHealthState::HEALTH_STATE_UNKNOWN);
int32_t errCode = g_proxy->GetHealthStatus(healthStateValue);
EXPECT_TRUE(errCode == INVALID_VALUE || errCode == ERR_INVALID_VALUE || errCode == ERR_INVALID_DATA);
BatteryHealthState healthState = static_cast<BatteryHealthState>(healthStateValue);
EXPECT_TRUE(healthState >= BatteryHealthState::HEALTH_STATE_UNKNOWN &&
healthState <= BatteryHealthState::HEALTH_STATE_BUTT); // the enum value range of BatteryHealthState
BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_003 function end!");
@@ -108,7 +118,10 @@ HWTEST_F(BatteryProxyMockTest, BatteryProxyMockTest_003, TestSize.Level0)
HWTEST_F(BatteryProxyMockTest, BatteryProxyMockTest_004, TestSize.Level0)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_004 function start!");
BatteryPluggedType pluggedType = g_proxy->GetPluggedType();
uint32_t pluggedTypeValue = static_cast<uint32_t>(BatteryPluggedType::PLUGGED_TYPE_NONE);
int32_t errCode = g_proxy->GetPluggedType(pluggedTypeValue);
EXPECT_TRUE(errCode == INVALID_VALUE || errCode == ERR_INVALID_VALUE || errCode == ERR_INVALID_DATA);
BatteryPluggedType pluggedType = static_cast<BatteryPluggedType>(pluggedTypeValue);
EXPECT_TRUE(pluggedType >= BatteryPluggedType::PLUGGED_TYPE_NONE &&
pluggedType <= BatteryPluggedType::PLUGGED_TYPE_BUTT); // the enum value range of BatteryPluggedType
BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_004 function end!");
@@ -123,7 +136,9 @@ HWTEST_F(BatteryProxyMockTest, BatteryProxyMockTest_004, TestSize.Level0)
HWTEST_F(BatteryProxyMockTest, BatteryProxyMockTest_005, TestSize.Level0)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_005 function start!");
bool isPresent = g_proxy->GetPresent();
bool isPresent = INVALID_BATT_BOOL_VALUE;
int32_t errCode = g_proxy->GetPresent(isPresent);
EXPECT_TRUE(errCode == INVALID_VALUE || errCode == ERR_INVALID_VALUE || errCode == ERR_INVALID_DATA);
EXPECT_TRUE(isPresent == INVALID_BATT_BOOL_VALUE);
BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_005 function end!");
}
@@ -137,7 +152,9 @@ HWTEST_F(BatteryProxyMockTest, BatteryProxyMockTest_005, TestSize.Level0)
HWTEST_F(BatteryProxyMockTest, BatteryProxyMockTest_006, TestSize.Level0)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_006 function start!");
std::string technology = g_proxy->GetTechnology();
std::string technology = INVALID_STRING_VALUE;
int32_t errCode = g_proxy->GetTechnology(technology);
EXPECT_TRUE(errCode == INVALID_VALUE || errCode == ERR_INVALID_VALUE || errCode == ERR_INVALID_DATA);
EXPECT_TRUE(technology == INVALID_STRING_VALUE);
BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_006 function end!");
}
@@ -151,7 +168,9 @@ HWTEST_F(BatteryProxyMockTest, BatteryProxyMockTest_006, TestSize.Level0)
HWTEST_F(BatteryProxyMockTest, BatteryProxyMockTest_007, TestSize.Level0)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_007 function start!");
int32_t totalEnergy = g_proxy->GetTotalEnergy();
int32_t totalEnergy = INVALID_BATT_INT_VALUE;
int32_t errCode = g_proxy->GetTotalEnergy(totalEnergy);
EXPECT_TRUE(errCode == INVALID_VALUE || errCode == ERR_INVALID_VALUE || errCode == ERR_INVALID_DATA);
EXPECT_TRUE(totalEnergy == INVALID_BATT_INT_VALUE);
BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_007 function end!");
}
@@ -165,7 +184,9 @@ HWTEST_F(BatteryProxyMockTest, BatteryProxyMockTest_007, TestSize.Level0)
HWTEST_F(BatteryProxyMockTest, BatteryProxyMockTest_008, TestSize.Level0)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_008 function start!");
int32_t currentAverage = g_proxy->GetCurrentAverage();
int32_t currentAverage = INVALID_BATT_INT_VALUE;
int32_t errCode = g_proxy->GetCurrentAverage(currentAverage);
EXPECT_TRUE(errCode == INVALID_VALUE || errCode == ERR_INVALID_VALUE || errCode == ERR_INVALID_DATA);
EXPECT_TRUE(currentAverage == INVALID_BATT_INT_VALUE);
BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_008 function end!");
}
@@ -179,7 +200,9 @@ HWTEST_F(BatteryProxyMockTest, BatteryProxyMockTest_008, TestSize.Level0)
HWTEST_F(BatteryProxyMockTest, BatteryProxyMockTest_009, TestSize.Level0)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_009 function start!");
int32_t nowCurrent = g_proxy->GetNowCurrent();
int32_t nowCurrent = INVALID_BATT_INT_VALUE;
int32_t errCode = g_proxy->GetNowCurrent(nowCurrent);
EXPECT_TRUE(errCode == INVALID_VALUE || errCode == ERR_INVALID_VALUE || errCode == ERR_INVALID_DATA);
EXPECT_TRUE(nowCurrent == INVALID_BATT_INT_VALUE);
BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_009 function end!");
}
@@ -193,7 +216,9 @@ HWTEST_F(BatteryProxyMockTest, BatteryProxyMockTest_009, TestSize.Level0)
HWTEST_F(BatteryProxyMockTest, BatteryProxyMockTest_010, TestSize.Level0)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_010 function start!");
int32_t remainEnergy = g_proxy->GetRemainEnergy();
int32_t remainEnergy = INVALID_BATT_INT_VALUE;
int32_t errCode = g_proxy->GetRemainEnergy(remainEnergy);
EXPECT_TRUE(errCode == INVALID_VALUE || errCode == ERR_INVALID_VALUE || errCode == ERR_INVALID_DATA);
EXPECT_TRUE(remainEnergy == INVALID_BATT_INT_VALUE);
BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_010 function end!");
}
@@ -207,7 +232,9 @@ HWTEST_F(BatteryProxyMockTest, BatteryProxyMockTest_010, TestSize.Level0)
HWTEST_F(BatteryProxyMockTest, BatteryProxyMockTest_011, TestSize.Level0)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_011 function start!");
int32_t temperature = g_proxy->GetBatteryTemperature();
int32_t temperature = INVALID_BATT_TEMP_VALUE;
int32_t errCode = g_proxy->GetBatteryTemperature(temperature);
EXPECT_TRUE(errCode == INVALID_VALUE || errCode == ERR_INVALID_VALUE || errCode == ERR_INVALID_DATA);
EXPECT_TRUE(temperature == INVALID_BATT_TEMP_VALUE);
BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_011 function end!");
}
@@ -221,7 +248,10 @@ HWTEST_F(BatteryProxyMockTest, BatteryProxyMockTest_011, TestSize.Level0)
HWTEST_F(BatteryProxyMockTest, BatteryProxyMockTest_012, TestSize.Level0)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_012 function start!");
BatteryCapacityLevel batteryLevel = g_proxy->GetCapacityLevel();
uint32_t batteryLevelValue = 0;
int32_t errCode = g_proxy->GetCapacityLevel(batteryLevelValue);
EXPECT_TRUE(errCode == INVALID_VALUE || errCode == ERR_INVALID_VALUE || errCode == ERR_INVALID_DATA);
BatteryCapacityLevel batteryLevel = static_cast<BatteryCapacityLevel>(batteryLevelValue);
EXPECT_TRUE(batteryLevel >= BatteryCapacityLevel::LEVEL_NONE &&
batteryLevel <= BatteryCapacityLevel::LEVEL_RESERVED); // the enum value range of BatteryCapacityLevel
BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_012 function end!");
@@ -236,7 +266,9 @@ HWTEST_F(BatteryProxyMockTest, BatteryProxyMockTest_012, TestSize.Level0)
HWTEST_F(BatteryProxyMockTest, BatteryProxyMockTest_013, TestSize.Level0)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_013 function start!");
int64_t remainChargeTime = g_proxy->GetRemainingChargeTime();
int64_t remainChargeTime = INVALID_REMAINING_CHARGE_TIME_VALUE;
int32_t errCode = g_proxy->GetRemainingChargeTime(remainChargeTime);
EXPECT_TRUE(errCode == INVALID_VALUE || errCode == ERR_INVALID_VALUE || errCode == ERR_INVALID_DATA);
EXPECT_TRUE(remainChargeTime == INVALID_REMAINING_CHARGE_TIME_VALUE);
BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_013 function end!");
}
@@ -250,7 +282,9 @@ HWTEST_F(BatteryProxyMockTest, BatteryProxyMockTest_013, TestSize.Level0)
HWTEST_F(BatteryProxyMockTest, BatteryProxyMockTest_014, TestSize.Level0)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_014 function start!");
int32_t voltage = g_proxy->GetVoltage();
int32_t voltage = INVALID_BATT_INT_VALUE;
int32_t errCode = g_proxy->GetVoltage(voltage);
EXPECT_TRUE(errCode == INVALID_VALUE || errCode == ERR_INVALID_VALUE || errCode == ERR_INVALID_DATA);
EXPECT_TRUE(voltage == INVALID_BATT_INT_VALUE);
BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_014 function end!");
}
test/unittest/src/battery_srv_stub_test.cpp
+11 -11
View File
@@ -19,7 +19,7 @@
#include "parcel.h"
#include "battery_log.h"
#include "battery_manager_ipc_interface_code.h"
#include "ibattery_srv.h"
#include "battery_service.h"
#include "battery_srv_proxy.h"
#include "ibattery_srv.h"
@@ -61,21 +61,21 @@ static HWTEST_F(BatterySrvStubTest, BatterySrvStub001, TestSize.Level1)
uint32_t code = 0;
MessageParcel data;
int32_t ret = g_service->OnRemoteRequest(code, data, g_reply, g_option);
EXPECT_EQ(ret, E_GET_POWER_SERVICE_FAILED);
EXPECT_EQ(ret, ERR_TRANSACTION_FAILED);
BATTERY_HILOGI(LABEL_TEST, "BatterySrvStub001 function end!");
}
/**
* @tc.name: BatterySrvStub002
* @tc.desc: Test BatterySrvInterfaceCode BATT_GET_CAPACITY to BATT_GET_BATTERY_REMAIN_ENERGY code
* @tc.desc: Test IBatterySrvIpcCode COMMAND_GET_CAPACITY to COMMAND_GET_REMAIN_ENERGY code
* @tc.type: FUNC
* @tc.require: issueI6KRS8
*/
static HWTEST_F(BatterySrvStubTest, BatterySrvStub002, TestSize.Level1)
{
BATTERY_HILOGI(LABEL_TEST, "BatterySrvStub002 function start!");
uint32_t begin = static_cast<uint32_t>(PowerMgr::BatterySrvInterfaceCode::BATT_GET_CAPACITY);
uint32_t end = static_cast<uint32_t>(PowerMgr::BatterySrvInterfaceCode::BATT_GET_BATTERY_REMAIN_ENERGY);
uint32_t begin = static_cast<uint32_t>(PowerMgr::IBatterySrvIpcCode::COMMAND_GET_CAPACITY);
uint32_t end = static_cast<uint32_t>(PowerMgr::IBatterySrvIpcCode::COMMAND_GET_REMAIN_ENERGY);
for (uint32_t code = begin; code <= end; ++code) {
g_data.WriteInterfaceToken(BatterySrvProxy::GetDescriptor());
int32_t ret = g_service->OnRemoteRequest(code, g_data, g_reply, g_option);
@@ -103,7 +103,7 @@ static HWTEST_F(BatterySrvStubTest, BatterySrvStub003, TestSize.Level1)
/**
* @tc.name: BatterySrvStub004
* @tc.desc: Test BatterySrvInterfaceCode SET_BATTERY_CONFIG
* @tc.desc: Test IBatterySrvIpcCode COMMAND_SET_BATTERY_CONFIG
* @tc.type: FUNC
* @tc.require: issueI6KRS8
*/
@@ -115,7 +115,7 @@ static HWTEST_F(BatterySrvStubTest, BatterySrvStub004, TestSize.Level1)
u16string value = Str8ToStr16("0");
g_data.WriteString16(sceneName);
g_data.WriteString16(value);
uint32_t code = static_cast<uint32_t>(PowerMgr::BatterySrvInterfaceCode::SET_BATTERY_CONFIG);
uint32_t code = static_cast<uint32_t>(PowerMgr::IBatterySrvIpcCode::COMMAND_SET_BATTERY_CONFIG);
int32_t ret = g_service->OnRemoteRequest(code, g_data, g_reply, g_option);
EXPECT_EQ(ret, ERR_OK) << "ret: " << ret << " code: " << code;
BATTERY_HILOGI(LABEL_TEST, "BatterySrvStub004 function end!");
@@ -123,7 +123,7 @@ static HWTEST_F(BatterySrvStubTest, BatterySrvStub004, TestSize.Level1)
/**
* @tc.name: BatterySrvStub005
* @tc.desc: Test BatterySrvInterfaceCode GET_BATTERY_CONFIG
* @tc.desc: Test IBatterySrvIpcCode COMMAND_GET_BATTERY_CONFIG
* @tc.type: FUNC
* @tc.require: issueI6KRS8
*/
@@ -133,7 +133,7 @@ static HWTEST_F(BatterySrvStubTest, BatterySrvStub005, TestSize.Level1)
g_data.WriteInterfaceToken(BatterySrvProxy::GetDescriptor());
u16string sceneName = Str8ToStr16("BatterySrvStub005");
g_data.WriteString16(sceneName);
uint32_t code = static_cast<uint32_t>(PowerMgr::BatterySrvInterfaceCode::GET_BATTERY_CONFIG);
uint32_t code = static_cast<uint32_t>(PowerMgr::IBatterySrvIpcCode::COMMAND_GET_BATTERY_CONFIG);
int32_t ret = g_service->OnRemoteRequest(code, g_data, g_reply, g_option);
EXPECT_EQ(ret, ERR_OK) << "ret: " << ret << " code: " << code;
BATTERY_HILOGI(LABEL_TEST, "BatterySrvStub005 function end!");
@@ -141,7 +141,7 @@ static HWTEST_F(BatterySrvStubTest, BatterySrvStub005, TestSize.Level1)
/**
* @tc.name: BatterySrvStub006
* @tc.desc: Test BatterySrvInterfaceCode SUPPORT_BATTERY_CONFIG
* @tc.desc: Test IBatterySrvIpcCode COMMAND_IS_BATTERY_CONFIG_SUPPORTED
* @tc.type: FUNC
* @tc.require: issueI6KRS8
*/
@@ -151,7 +151,7 @@ static HWTEST_F(BatterySrvStubTest, BatterySrvStub006, TestSize.Level1)
g_data.WriteInterfaceToken(BatterySrvProxy::GetDescriptor());
u16string sceneName = Str8ToStr16("BatterySrvStub006");
g_data.WriteString16(sceneName);
uint32_t code = static_cast<uint32_t>(PowerMgr::BatterySrvInterfaceCode::SUPPORT_BATTERY_CONFIG);
uint32_t code = static_cast<uint32_t>(PowerMgr::IBatterySrvIpcCode::COMMAND_IS_BATTERY_CONFIG_SUPPORTED);
int32_t ret = g_service->OnRemoteRequest(code, g_data, g_reply, g_option);
EXPECT_EQ(ret, ERR_OK) << "ret: " << ret << " code: " << code;
BATTERY_HILOGI(LABEL_TEST, "BatterySrvStub006 function end!");
test/unittest/src/interface_test/battery_client_test.cpp
+302
View File
@@ -33,6 +33,9 @@
#include "battery_srv_client.h"
#include "test_utils.h"
#include "mock_battery_srv_proxy.h"
#include "mock_remote_object.h"
using namespace testing::ext;
using namespace OHOS::PowerMgr;
using namespace OHOS;
@@ -48,18 +51,24 @@ constexpr int32_t BATTERY_HIGH_THRESHOLD = 99;
constexpr int32_t BATTERY_HIGH_FULL = 100;
const std::string MOCK_BATTERY_PATH = "/data/service/el0/battery/";
BatteryInfo g_info;
sptr<IRemoteObject> g_testRemoteObj;
sptr<MockBatterySrvProxy> g_mockProxy;
}
void BatteryClientTest::SetUpTestCase(void)
{
g_isMock = TestUtils::IsMock();
GTEST_LOG_(INFO) << " g_isMock: " << g_isMock;
g_testRemoteObj = sptr<MockRemoteObject>::MakeSptr(u"BatteryTest");
g_mockProxy = sptr<MockBatterySrvProxy>::MakeSptr(g_testRemoteObj);
}
void BatteryClientTest::TearDownTestCase(void)
{
g_isMock = false;
TestUtils::ResetOnline();
g_testRemoteObj = nullptr;
g_mockProxy = nullptr;
}
void BatteryClientTest::SetUp(void)
@@ -784,4 +793,297 @@ HWTEST_F (BatteryClientTest, BatteryClient023, TestSize.Level1)
BATTERY_HILOGI(LABEL_TEST, "BatteryClient::BatteryClient023 function end!");
}
/**
* @tc.name: BatteryClient024
* @tc.desc: test GetCapacity() when proxy return fail
* @tc.type: FUNC
* @tc.require
*/
HWTEST_F(BatteryClientTest, BatteryClient024, TestSize.Level0)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryClient024 function start!");
auto& BatterySrvClient = BatterySrvClient::GetInstance();
auto proxy = BatterySrvClient.proxy_;
BatterySrvClient.proxy_ = g_mockProxy;
auto capacity = BatterySrvClient.GetCapacity();
BatterySrvClient.proxy_ = proxy;
EXPECT_TRUE(capacity == INVALID_BATT_INT_VALUE);
BATTERY_HILOGI(LABEL_TEST, "BatteryClient024 function end!");
}
/**
* @tc.name: BatteryClient025
* @tc.desc: test GetChargingStatus() when proxy return fail
* @tc.type: FUNC
* @tc.require
*/
HWTEST_F(BatteryClientTest, BatteryClient025, TestSize.Level0)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryClient024 function start!");
auto& BatterySrvClient = BatterySrvClient::GetInstance();
auto proxy = BatterySrvClient.proxy_;
BatterySrvClient.proxy_ = g_mockProxy;
auto chargingStatus = BatterySrvClient.GetChargingStatus();
BatterySrvClient.proxy_ = proxy;
EXPECT_TRUE(chargingStatus == BatteryChargeState::CHARGE_STATE_BUTT);
BATTERY_HILOGI(LABEL_TEST, "BatteryClient025 function end!");
}
/**
* @tc.name: BatteryClient026
* @tc.desc: test GetHealthStatus() when proxy return fail
* @tc.type: FUNC
* @tc.require
*/
HWTEST_F(BatteryClientTest, BatteryClient026, TestSize.Level0)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryClient026 function start!");
auto& BatterySrvClient = BatterySrvClient::GetInstance();
auto proxy = BatterySrvClient.proxy_;
BatterySrvClient.proxy_ = g_mockProxy;
auto healthStatus = BatterySrvClient.GetHealthStatus();
BatterySrvClient.proxy_ = proxy;
EXPECT_TRUE(healthStatus == BatteryHealthState::HEALTH_STATE_BUTT);
BATTERY_HILOGI(LABEL_TEST, "BatteryClient026 function end!");
}
/**
* @tc.name: BatteryClient027
* @tc.desc: test GetPluggedType() when proxy return fail
* @tc.type: FUNC
* @tc.require
*/
HWTEST_F(BatteryClientTest, BatteryClient027, TestSize.Level0)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryClient027 function start!");
auto& BatterySrvClient = BatterySrvClient::GetInstance();
auto proxy = BatterySrvClient.proxy_;
BatterySrvClient.proxy_ = g_mockProxy;
auto pluggedType = BatterySrvClient.GetPluggedType();
BatterySrvClient.proxy_ = proxy;
EXPECT_TRUE(pluggedType == BatteryPluggedType::PLUGGED_TYPE_BUTT);
BATTERY_HILOGI(LABEL_TEST, "BatteryClient027 function end!");
}
/**
* @tc.name: BatteryClient028
* @tc.desc: test GetVoltage() when proxy return fail
* @tc.type: FUNC
* @tc.require
*/
HWTEST_F(BatteryClientTest, BatteryClient028, TestSize.Level0)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryClient028 function start!");
auto& BatterySrvClient = BatterySrvClient::GetInstance();
auto proxy = BatterySrvClient.proxy_;
BatterySrvClient.proxy_ = g_mockProxy;
auto voltage = BatterySrvClient.GetVoltage();
BatterySrvClient.proxy_ = proxy;
EXPECT_TRUE(voltage == INVALID_BATT_INT_VALUE);
BATTERY_HILOGI(LABEL_TEST, "BatteryClient028 function end!");
}
/**
* @tc.name: BatteryClient029
* @tc.desc: test GetPresent() when proxy return fail
* @tc.type: FUNC
* @tc.require
*/
HWTEST_F(BatteryClientTest, BatteryClient029, TestSize.Level0)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryClient029 function start!");
auto& BatterySrvClient = BatterySrvClient::GetInstance();
auto proxy = BatterySrvClient.proxy_;
BatterySrvClient.proxy_ = g_mockProxy;
auto present = BatterySrvClient.GetPresent();
BatterySrvClient.proxy_ = proxy;
EXPECT_TRUE(present == INVALID_BATT_BOOL_VALUE);
BATTERY_HILOGI(LABEL_TEST, "BatteryClient029 function end!");
}
/**
* @tc.name: BatteryClient030
* @tc.desc: test GetTechnology() when proxy return fail
* @tc.type: FUNC
* @tc.require
*/
HWTEST_F(BatteryClientTest, BatteryClient030, TestSize.Level0)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryClient030 function start!");
auto& BatterySrvClient = BatterySrvClient::GetInstance();
auto proxy = BatterySrvClient.proxy_;
BatterySrvClient.proxy_ = g_mockProxy;
auto technology = BatterySrvClient.GetTechnology();
BatterySrvClient.proxy_ = proxy;
EXPECT_TRUE(technology == INVALID_STRING_VALUE);
BATTERY_HILOGI(LABEL_TEST, "BatteryClient030 function end!");
}
/**
* @tc.name: BatteryClient031
* @tc.desc: test GetTotalEnergy() when proxy return fail
* @tc.type: FUNC
* @tc.require
*/
HWTEST_F(BatteryClientTest, BatteryClient031, TestSize.Level0)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryClient031 function start!");
auto& BatterySrvClient = BatterySrvClient::GetInstance();
auto proxy = BatterySrvClient.proxy_;
BatterySrvClient.proxy_ = g_mockProxy;
auto totalEnergy = BatterySrvClient.GetTotalEnergy();
BatterySrvClient.proxy_ = proxy;
EXPECT_TRUE(totalEnergy == INVALID_BATT_INT_VALUE);
BATTERY_HILOGI(LABEL_TEST, "BatteryClient031 function end!");
}
/**
* @tc.name: BatteryClient032
* @tc.desc: test GetNowCurrent() when proxy return fail
* @tc.type: FUNC
* @tc.require
*/
HWTEST_F(BatteryClientTest, BatteryClient032, TestSize.Level0)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryClient032 function start!");
auto& BatterySrvClient = BatterySrvClient::GetInstance();
auto proxy = BatterySrvClient.proxy_;
BatterySrvClient.proxy_ = g_mockProxy;
auto nowCurr = BatterySrvClient.GetNowCurrent();
BatterySrvClient.proxy_ = proxy;
EXPECT_TRUE(nowCurr == INVALID_BATT_INT_VALUE);
BATTERY_HILOGI(LABEL_TEST, "BatteryClient032 function end!");
}
/**
* @tc.name: BatteryClient033
* @tc.desc: test GetRemainEnergy() when proxy return fail
* @tc.type: FUNC
* @tc.require
*/
HWTEST_F(BatteryClientTest, BatteryClient033, TestSize.Level0)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryClient033 function start!");
auto& BatterySrvClient = BatterySrvClient::GetInstance();
auto proxy = BatterySrvClient.proxy_;
BatterySrvClient.proxy_ = g_mockProxy;
auto remainEnergy = BatterySrvClient.GetRemainEnergy();
BatterySrvClient.proxy_ = proxy;
EXPECT_TRUE(remainEnergy == INVALID_BATT_INT_VALUE);
BATTERY_HILOGI(LABEL_TEST, "BatteryClient033 function end!");
}
/**
* @tc.name: BatteryClient034
* @tc.desc: test GetBatteryTemperature() when proxy return fail
* @tc.type: FUNC
* @tc.require
*/
HWTEST_F(BatteryClientTest, BatteryClient034, TestSize.Level0)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryClient034 function start!");
auto& BatterySrvClient = BatterySrvClient::GetInstance();
auto proxy = BatterySrvClient.proxy_;
BatterySrvClient.proxy_ = g_mockProxy;
auto temperature = BatterySrvClient.GetBatteryTemperature();
BatterySrvClient.proxy_ = proxy;
EXPECT_TRUE(temperature == INVALID_BATT_TEMP_VALUE);
BATTERY_HILOGI(LABEL_TEST, "BatteryClient034 function end!");
}
/**
* @tc.name: BatteryClient035
* @tc.desc: test GetCapacityLevel() when proxy return fail
* @tc.type: FUNC
* @tc.require
*/
HWTEST_F(BatteryClientTest, BatteryClient035, TestSize.Level0)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryClient035 function start!");
auto& BatterySrvClient = BatterySrvClient::GetInstance();
auto proxy = BatterySrvClient.proxy_;
BatterySrvClient.proxy_ = g_mockProxy;
auto batteryCapacityLevel = BatterySrvClient.GetCapacityLevel();
BatterySrvClient.proxy_ = proxy;
EXPECT_TRUE(batteryCapacityLevel == BatteryCapacityLevel::LEVEL_NONE);
BATTERY_HILOGI(LABEL_TEST, "BatteryClient035 function end!");
}
/**
* @tc.name: BatteryClient036
* @tc.desc: test GetRemainingChargeTime() when proxy return fail
* @tc.type: FUNC
* @tc.require
*/
HWTEST_F(BatteryClientTest, BatteryClient036, TestSize.Level0)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryClient036 function start!");
auto& BatterySrvClient = BatterySrvClient::GetInstance();
auto proxy = BatterySrvClient.proxy_;
BatterySrvClient.proxy_ = g_mockProxy;
auto remainTime = BatterySrvClient.GetRemainingChargeTime();
BatterySrvClient.proxy_ = proxy;
EXPECT_TRUE(remainTime == INVALID_REMAINING_CHARGE_TIME_VALUE);
BATTERY_HILOGI(LABEL_TEST, "BatteryClient036 function end!");
}
/**
* @tc.name: BatteryClient037
* @tc.desc: test SetBatteryConfig() when proxy return fail
* @tc.type: FUNC
* @tc.require
*/
HWTEST_F(BatteryClientTest, BatteryClient037, TestSize.Level0)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryClient037 function start!");
auto& BatterySrvClient = BatterySrvClient::GetInstance();
auto proxy = BatterySrvClient.proxy_;
BatterySrvClient.proxy_ = g_mockProxy;
std::string sceneName = "test";
std::string value = "test";
auto batteryErr = BatterySrvClient.SetBatteryConfig(sceneName, value);
BatterySrvClient.proxy_ = proxy;
EXPECT_NE(batteryErr, BatteryError::ERR_OK);
BATTERY_HILOGI(LABEL_TEST, "BatteryClient037 function end!");
}
/**
* @tc.name: BatteryClient038
* @tc.desc: test GetBatteryConfig() when proxy return fail
* @tc.type: FUNC
* @tc.require
*/
HWTEST_F(BatteryClientTest, BatteryClient038, TestSize.Level0)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryClient038 function start!");
auto& BatterySrvClient = BatterySrvClient::GetInstance();
auto proxy = BatterySrvClient.proxy_;
BatterySrvClient.proxy_ = g_mockProxy;
std::string sceneName = "test";
std::string getResult;
auto batteryErr = BatterySrvClient.GetBatteryConfig(sceneName, getResult);
BatterySrvClient.proxy_ = proxy;
EXPECT_NE(batteryErr, BatteryError::ERR_OK);
BATTERY_HILOGI(LABEL_TEST, "BatteryClient038 function end!");
}
/**
* @tc.name: BatteryClient039
* @tc.desc: test IsBatteryConfigSupported() when proxy return fail
* @tc.type: FUNC
* @tc.require
*/
HWTEST_F(BatteryClientTest, BatteryClient039, TestSize.Level0)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryClient039 function start!");
auto& BatterySrvClient = BatterySrvClient::GetInstance();
auto proxy = BatterySrvClient.proxy_;
BatterySrvClient.proxy_ = g_mockProxy;
std::string featureName = "test";
bool isResult = false;
auto batteryErr = BatterySrvClient.IsBatteryConfigSupported(featureName, isResult);
BatterySrvClient.proxy_ = proxy;
EXPECT_NE(batteryErr, BatteryError::ERR_OK);
BATTERY_HILOGI(LABEL_TEST, "BatteryClient039 function end!");
}
} // namespace
test/unittest/src/interface_test/battery_service_test.cpp
+464 -25
View File
@@ -32,6 +32,7 @@
#include "common_event_support.h"
#include "securec.h"
#include "test_utils.h"
#include "battery_xcollie.h"
using namespace testing::ext;
using namespace OHOS::PowerMgr;
@@ -45,6 +46,10 @@ sptr<BatteryService> g_service;
bool g_isMock = TestUtils::IsMock();
const std::string MOCK_BATTERY_PATH = "/data/service/el0/battery/";
constexpr int DELAY_TIME_US = 200000;
constexpr int TEST_CAPACITY_MIN = 0;
constexpr int TEST_CAPACITY_MAX = 100;
constexpr int TEST_CAPACITY_FIRST = 50;
constexpr int TEST_CAPACITY_SECOND = 60;
}
void BatteryServiceTest::TearDownTestCase(void)
@@ -93,13 +98,13 @@ static HWTEST_F(BatteryServiceTest, BatteryService004, TestSize.Level1)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryService004 function start!");
if (g_isMock) {
auto tempVoltage = g_service->GetVoltage();
auto tempVoltage = g_service->GetVoltageInner();
TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/voltage_now", "4654321");
auto voltage = g_service->GetVoltage();
auto voltage = g_service->GetVoltageInner();
EXPECT_TRUE(voltage == 4654321);
TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/voltage_now", std::to_string(tempVoltage));
} else {
auto voltage = g_service->GetVoltage();
auto voltage = g_service->GetVoltageInner();
BATTERY_HILOGI(LABEL_TEST, "BatteryService004::voltage=%{public}d", voltage);
GTEST_LOG_(INFO) << "BatteryService004 executing, voltage=" << voltage;
EXPECT_TRUE(voltage >= 0);
@@ -118,18 +123,24 @@ static HWTEST_F(BatteryServiceTest, BatteryService005, TestSize.Level1)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryService005 function start!");
if (g_isMock) {
auto tempPresent = g_service->GetPresent();
auto tempPresent = g_service->GetPresentInner();
TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/present", "0");
auto present = g_service->GetPresent();
auto present = g_service->GetPresentInner();
BATTERY_HILOGI(LABEL_TEST, "BatteryService005::present=%{public}d", present);
GTEST_LOG_(INFO) << "BatteryService005 executing, present=" << present;
EXPECT_FALSE(present);
auto presentIdl = false;
g_service->GetPresent(presentIdl);
EXPECT_EQ(present, presentIdl);
TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/present", std::to_string(tempPresent));
} else {
auto present = g_service->GetPresent();
auto present = g_service->GetPresentInner();
BATTERY_HILOGI(LABEL_TEST, "BatteryService005::present=%{public}d", present);
GTEST_LOG_(INFO) << "BatteryService005 executing, present=" << present;
EXPECT_TRUE(present);
auto presentIdl = false;
g_service->GetPresent(presentIdl);
EXPECT_EQ(present, presentIdl);
}
BATTERY_HILOGI(LABEL_TEST, "BatteryService005 function end!");
}
@@ -144,15 +155,15 @@ static HWTEST_F(BatteryServiceTest, BatteryService006, TestSize.Level1)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryService006 function start!");
if (g_isMock) {
auto tempTempPresent = g_service->GetBatteryTemperature();
auto tempTempPresent = g_service->GetBatteryTemperatureInner();
TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/temp", "222");
auto temperature = g_service->GetBatteryTemperature();
auto temperature = g_service->GetBatteryTemperatureInner();
BATTERY_HILOGI(LABEL_TEST, "BatteryService006::temperature=%{public}d", temperature);
GTEST_LOG_(INFO) << "BatteryService006 executing, temperature=" << temperature;
EXPECT_TRUE(temperature == 222);
TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/temp", std::to_string(tempTempPresent));
} else {
auto temperature = g_service->GetBatteryTemperature();
auto temperature = g_service->GetBatteryTemperatureInner();
BATTERY_HILOGI(LABEL_TEST, "BatteryService006::temperature=%{public}d", temperature);
GTEST_LOG_(INFO) << "BatteryService006 executing, temperature=" << temperature;
EXPECT_TRUE(temperature >= 0 && temperature <= 600);
@@ -224,7 +235,7 @@ static HWTEST_F(BatteryServiceTest, BatteryService009, TestSize.Level1)
static HWTEST_F(BatteryServiceTest, BatteryService010, TestSize.Level1)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryService010 function start!");
EXPECT_NE(g_service->GetRemainEnergy(), ERR_NO_INIT);
EXPECT_NE(g_service->GetRemainEnergyInner(), ERR_NO_INIT);
BATTERY_HILOGI(LABEL_TEST, "BatteryService010 function end!");
}
@@ -237,7 +248,7 @@ static HWTEST_F(BatteryServiceTest, BatteryService010, TestSize.Level1)
static HWTEST_F(BatteryServiceTest, BatteryService011, TestSize.Level1)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryService011 function start!");
EXPECT_NE(g_service->GetNowCurrent(), ERR_NO_INIT);
EXPECT_NE(g_service->GetNowCurrentInner(), ERR_NO_INIT);
BATTERY_HILOGI(LABEL_TEST, "BatteryService011 function end!");
}
@@ -250,7 +261,7 @@ static HWTEST_F(BatteryServiceTest, BatteryService011, TestSize.Level1)
static HWTEST_F(BatteryServiceTest, BatteryService012, TestSize.Level1)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryService012 function start!");
EXPECT_FALSE(g_service->GetTechnology().empty());
EXPECT_FALSE(g_service->GetTechnologyInner().empty());
BATTERY_HILOGI(LABEL_TEST, "BatteryService012 function end!");
}
@@ -263,7 +274,7 @@ static HWTEST_F(BatteryServiceTest, BatteryService012, TestSize.Level1)
static HWTEST_F(BatteryServiceTest, BatteryService013, TestSize.Level1)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryService013 function start!");
BatteryPluggedType pluggedType = g_service->GetPluggedType();
BatteryPluggedType pluggedType = g_service->GetPluggedTypeInner();
EXPECT_TRUE(
pluggedType >= BatteryPluggedType::PLUGGED_TYPE_NONE && pluggedType <= BatteryPluggedType::PLUGGED_TYPE_BUTT);
BATTERY_HILOGI(LABEL_TEST, "BatteryService013 function end!");
@@ -278,7 +289,7 @@ static HWTEST_F(BatteryServiceTest, BatteryService013, TestSize.Level1)
static HWTEST_F(BatteryServiceTest, BatteryService014, TestSize.Level1)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryService014 function start!");
EXPECT_NE(g_service->GetCurrentAverage(), ERR_NO_INIT);
EXPECT_NE(g_service->GetCurrentAverageInner(), ERR_NO_INIT);
BATTERY_HILOGI(LABEL_TEST, "BatteryService014 function end!");
}
@@ -291,7 +302,7 @@ static HWTEST_F(BatteryServiceTest, BatteryService014, TestSize.Level1)
static HWTEST_F(BatteryServiceTest, BatteryService015, TestSize.Level1)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryService015 function start!");
BatteryHealthState healthState = g_service->GetHealthStatus();
BatteryHealthState healthState = g_service->GetHealthStatusInner();
EXPECT_TRUE(healthState >= BatteryHealthState::HEALTH_STATE_UNKNOWN &&
healthState <= BatteryHealthState::HEALTH_STATE_BUTT);
BATTERY_HILOGI(LABEL_TEST, "BatteryService015 function end!");
@@ -306,7 +317,7 @@ static HWTEST_F(BatteryServiceTest, BatteryService015, TestSize.Level1)
static HWTEST_F(BatteryServiceTest, BatteryService016, TestSize.Level1)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryService016 function start!");
BatteryChargeState chargeState = g_service->GetChargingStatus();
BatteryChargeState chargeState = g_service->GetChargingStatusInner();
EXPECT_TRUE(
chargeState >= BatteryChargeState::CHARGE_STATE_NONE && chargeState <= BatteryChargeState::CHARGE_STATE_BUTT);
BATTERY_HILOGI(LABEL_TEST, "BatteryService016 function end!");
@@ -321,7 +332,7 @@ static HWTEST_F(BatteryServiceTest, BatteryService016, TestSize.Level1)
static HWTEST_F(BatteryServiceTest, BatteryService017, TestSize.Level1)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryService017 function start!");
EXPECT_NE(g_service->GetTotalEnergy(), ERR_NO_INIT);
EXPECT_NE(g_service->GetTotalEnergyInner(), ERR_NO_INIT);
BATTERY_HILOGI(LABEL_TEST, "BatteryService017 function end!");
}
@@ -416,35 +427,35 @@ static HWTEST_F(BatteryServiceTest, BatteryService021, TestSize.Level1)
BATTERY_HILOGI(LABEL_TEST, "BatteryService021 function start!");
if (g_isMock) {
TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "1");
auto level = g_service->GetCapacityLevel();
auto level = g_service->GetCapacityLevelInner();
EXPECT_EQ(level, BatteryCapacityLevel::LEVEL_SHUTDOWN);
TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "4");
level = g_service->GetCapacityLevel();
level = g_service->GetCapacityLevelInner();
EXPECT_EQ(level, BatteryCapacityLevel::LEVEL_CRITICAL);
TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "10");
level = g_service->GetCapacityLevel();
level = g_service->GetCapacityLevelInner();
EXPECT_EQ(level, BatteryCapacityLevel::LEVEL_WARNING);
TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "15");
level = g_service->GetCapacityLevel();
level = g_service->GetCapacityLevelInner();
EXPECT_EQ(level, BatteryCapacityLevel::LEVEL_LOW);
TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "90");
level = g_service->GetCapacityLevel();
level = g_service->GetCapacityLevelInner();
EXPECT_EQ(level, BatteryCapacityLevel::LEVEL_NORMAL);
TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "99");
level = g_service->GetCapacityLevel();
level = g_service->GetCapacityLevelInner();
EXPECT_EQ(level, BatteryCapacityLevel::LEVEL_HIGH);
TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "100");
level = g_service->GetCapacityLevel();
level = g_service->GetCapacityLevelInner();
EXPECT_EQ(level, BatteryCapacityLevel::LEVEL_FULL);
TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "200");
level = g_service->GetCapacityLevel();
level = g_service->GetCapacityLevelInner();
EXPECT_EQ(level, BatteryCapacityLevel::LEVEL_NONE);
TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "50");
@@ -486,3 +497,431 @@ static HWTEST_F(BatteryServiceTest, BatteryService023, TestSize.Level1)
BATTERY_HILOGI(LABEL_TEST, "BatteryService023 function end!");
}
/**
* @tc.name: BatteryService024
* @tc.desc: Test functions GetVoltage
* @tc.type: FUNC
* @tc.require:
*/
static HWTEST_F(BatteryServiceTest, BatteryService024, TestSize.Level1)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryService024 function start!");
if (g_isMock) {
int32_t tempVoltage = 0;
EXPECT_EQ(g_service->GetVoltage(tempVoltage), ERR_OK);
TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/voltage_now", "4654321");
int32_t voltage = 0;
g_service->GetVoltage(voltage);
EXPECT_TRUE(voltage == 4654321);
TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/voltage_now", std::to_string(tempVoltage));
} else {
int32_t voltage = 0;
g_service->GetVoltage(voltage);
BATTERY_HILOGI(LABEL_TEST, "BatteryService024::voltage=%{public}d", voltage);
GTEST_LOG_(INFO) << "BatteryService024 executing, voltage=" << voltage;
EXPECT_TRUE(voltage >= 0);
}
BATTERY_HILOGI(LABEL_TEST, "BatteryService024 function end!");
}
/**
* @tc.name: BatteryService025
* @tc.desc: Test functions IsBatteryConfigSupported
* @tc.type: FUNC
*/
static HWTEST_F(BatteryServiceTest, BatteryService025, TestSize.Level1)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryService025 function start!");
string sceneName = "testScene";
int32_t batteryErr = static_cast<int32_t>(BatteryError::ERR_FAILURE);
bool result = false;
g_service->IsBatteryConfigSupported(sceneName, result, batteryErr);
EXPECT_EQ(batteryErr, static_cast<int32_t>(BatteryError::ERR_FAILURE));
BATTERY_HILOGI(LABEL_TEST, "BatteryService025 function end!");
}
/**
* @tc.name: BatteryService026
* @tc.desc: Test functions GetBatteryTemperature
* @tc.type: FUNC
* @tc.require:
*/
static HWTEST_F(BatteryServiceTest, BatteryService026, TestSize.Level1)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryService026 function start!");
if (g_isMock) {
int32_t tempTemperature = 0;
g_service->GetBatteryTemperature(tempTemperature);
TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/temp", "222");
int32_t temperature = 0;
g_service->GetBatteryTemperature(temperature);
BATTERY_HILOGI(LABEL_TEST, "BatteryService026::temperature=%{public}d", temperature);
GTEST_LOG_(INFO) << "BatteryService026 executing, temperature=" << temperature;
EXPECT_TRUE(temperature == 222);
TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/temp", std::to_string(tempTemperature));
} else {
int32_t temperature = 0;
g_service->GetBatteryTemperature(temperature);
BATTERY_HILOGI(LABEL_TEST, "BatteryService026::temperature=%{public}d", temperature);
GTEST_LOG_(INFO) << "BatteryService026 executing, temperature=" << temperature;
EXPECT_TRUE(temperature >= 0 && temperature <= 600);
}
BATTERY_HILOGI(LABEL_TEST, "BatteryService026 function end!");
}
/**
* @tc.name: BatteryService027
* @tc.desc: Test functions GetRemainEnergy
* @tc.type: FUNC
* @tc.require:
*/
static HWTEST_F(BatteryServiceTest, BatteryService027, TestSize.Level1)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryService027 function start!");
int32_t remainEnergy = 0;
g_service->GetRemainEnergy(remainEnergy);
EXPECT_NE(remainEnergy, ERR_NO_INIT);
BATTERY_HILOGI(LABEL_TEST, "BatteryService027 function end!");
}
/**
* @tc.name: BatteryService028
* @tc.desc: Test functions GetNowCurrent
* @tc.type: FUNC
* @tc.require:
*/
static HWTEST_F(BatteryServiceTest, BatteryService028, TestSize.Level1)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryService028 function start!");
int32_t nowCurrent = 0;
g_service->GetNowCurrent(nowCurrent);
EXPECT_NE(nowCurrent, ERR_NO_INIT);
BATTERY_HILOGI(LABEL_TEST, "BatteryService028 function end!");
}
/**
* @tc.name: BatteryService029
* @tc.desc: Test functions GetTechnology
* @tc.type: FUNC
* @tc.require:
*/
static HWTEST_F(BatteryServiceTest, BatteryService029, TestSize.Level1)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryService029 function start!");
std::string technology;
g_service->GetTechnology(technology);
EXPECT_FALSE(technology.empty());
BATTERY_HILOGI(LABEL_TEST, "BatteryService029 function end!");
}
/**
* @tc.name: BatteryService030
* @tc.desc: Test functions GetPluggedType
* @tc.type: FUNC
* @tc.require:
*/
static HWTEST_F(BatteryServiceTest, BatteryService030, TestSize.Level1)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryService030 function start!");
uint32_t pluggedTypeTemp = 0;
g_service->GetPluggedType(pluggedTypeTemp);
BatteryPluggedType pluggedType = static_cast<BatteryPluggedType>(pluggedTypeTemp);
EXPECT_TRUE(
pluggedType >= BatteryPluggedType::PLUGGED_TYPE_NONE && pluggedType <= BatteryPluggedType::PLUGGED_TYPE_BUTT);
BATTERY_HILOGI(LABEL_TEST, "BatteryService030 function end!");
}
/**
* @tc.name: BatteryService031
* @tc.desc: Test functions GetCurrentAverage
* @tc.type: FUNC
* @tc.require:
*/
static HWTEST_F(BatteryServiceTest, BatteryService031, TestSize.Level1)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryService031 function start!");
int32_t currentAverage = 0;
g_service->GetCurrentAverage(currentAverage);
EXPECT_NE(currentAverage, ERR_NO_INIT);
BATTERY_HILOGI(LABEL_TEST, "BatteryService031 function end!");
}
/**
* @tc.name: BatteryService032
* @tc.desc: Test functions GetHealthStatus
* @tc.type: FUNC
* @tc.require:
*/
static HWTEST_F(BatteryServiceTest, BatteryService032, TestSize.Level1)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryService032 function start!");
uint32_t healthStateTemp = 0;
g_service->GetHealthStatus(healthStateTemp);
BatteryHealthState healthState = static_cast<BatteryHealthState>(healthStateTemp);
EXPECT_TRUE(healthState >= BatteryHealthState::HEALTH_STATE_UNKNOWN &&
healthState <= BatteryHealthState::HEALTH_STATE_BUTT);
BATTERY_HILOGI(LABEL_TEST, "BatteryService032 function end!");
}
/**
* @tc.name: BatteryService033
* @tc.desc: Test functions GetChargingStatus
* @tc.type: FUNC
* @tc.require:
*/
static HWTEST_F(BatteryServiceTest, BatteryService033, TestSize.Level1)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryService033 function start!");
uint32_t chargingStateTemp = 0;
g_service->GetChargingStatus(chargingStateTemp);
BatteryChargeState chargeState = static_cast<BatteryChargeState>(chargingStateTemp);
EXPECT_TRUE(
chargeState >= BatteryChargeState::CHARGE_STATE_NONE && chargeState <= BatteryChargeState::CHARGE_STATE_BUTT);
BATTERY_HILOGI(LABEL_TEST, "BatteryService033 function end!");
}
/**
* @tc.name: BatteryService034
* @tc.desc: Test functions GetTotalEnergy
* @tc.type: FUNC
* @tc.require:
*/
static HWTEST_F(BatteryServiceTest, BatteryService034, TestSize.Level1)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryService034 function start!");
int32_t totalEnergy = 0;
g_service->GetTotalEnergy(totalEnergy);
EXPECT_NE(totalEnergy, ERR_NO_INIT);
BATTERY_HILOGI(LABEL_TEST, "BatteryService034 function end!");
}
/**
* @tc.name: BatteryService035
* @tc.desc: Test functions GetCapacityLevel
* @tc.type: FUNC
*/
static HWTEST_F(BatteryServiceTest, BatteryService035, TestSize.Level1)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryService035 function start!");
if (g_isMock) {
TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "1");
uint32_t level = 0;
g_service->GetCapacityLevel(level);
EXPECT_EQ(static_cast<BatteryCapacityLevel>(level), BatteryCapacityLevel::LEVEL_SHUTDOWN);
TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "4");
g_service->GetCapacityLevel(level);
EXPECT_EQ(static_cast<BatteryCapacityLevel>(level), BatteryCapacityLevel::LEVEL_CRITICAL);
TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "10");
g_service->GetCapacityLevel(level);
EXPECT_EQ(static_cast<BatteryCapacityLevel>(level), BatteryCapacityLevel::LEVEL_WARNING);
TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "15");
g_service->GetCapacityLevel(level);
EXPECT_EQ(static_cast<BatteryCapacityLevel>(level), BatteryCapacityLevel::LEVEL_LOW);
TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "90");
g_service->GetCapacityLevel(level);
EXPECT_EQ(static_cast<BatteryCapacityLevel>(level), BatteryCapacityLevel::LEVEL_NORMAL);
TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "99");
g_service->GetCapacityLevel(level);
EXPECT_EQ(static_cast<BatteryCapacityLevel>(level), BatteryCapacityLevel::LEVEL_HIGH);
TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "100");
g_service->GetCapacityLevel(level);
EXPECT_EQ(static_cast<BatteryCapacityLevel>(level), BatteryCapacityLevel::LEVEL_FULL);
TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "200");
g_service->GetCapacityLevel(level);
EXPECT_EQ(static_cast<BatteryCapacityLevel>(level), BatteryCapacityLevel::LEVEL_NONE);
TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "50");
}
BATTERY_HILOGI(LABEL_TEST, "BatteryService035 function end!");
}
/**
* @tc.name: BatteryService036
* @tc.desc: Test functions GetCapacity
* @tc.type: FUNC
* @tc.require: issueI5YZR1
*/
HWTEST_F(BatteryServiceTest, BatteryService036, TestSize.Level1)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryService036 function start!");
int32_t capacity = 0;
auto ret = g_service->GetCapacity(capacity);
EXPECT_EQ(ret, ERR_OK);
ASSERT_TRUE(capacity <= 100 && capacity >= 0);
BATTERY_HILOGI(LABEL_TEST, "BatteryService036 function end!");
}
/**
* @tc.name: BatteryService037
* @tc.desc: Test functions GetRemainingChargeTime
* @tc.type: FUNC
* @tc.require: issueI5YZR1
*/
HWTEST_F(BatteryServiceTest, BatteryService037, TestSize.Level1)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryService037 function start!");
int64_t remainTime = 0;
auto ret = g_service->GetRemainingChargeTime(remainTime);
EXPECT_EQ(ret, ERR_OK);
ASSERT_TRUE(remainTime >= 0);
BATTERY_HILOGI(LABEL_TEST, "BatteryService037 function end!");
}
/**
* @tc.name: BatteryService038
* @tc.desc: Test functions GetRemainingChargeTime
* @tc.type: FUNC
* @tc.require:
*/
HWTEST_F(BatteryServiceTest, BatteryService038, TestSize.Level1)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryService038 function start!");
auto ret = g_service->CapacityLevelCompare(TEST_CAPACITY_FIRST, TEST_CAPACITY_MIN, TEST_CAPACITY_MAX);
ASSERT_TRUE(ret);
ret = g_service->CapacityLevelCompare(TEST_CAPACITY_FIRST, TEST_CAPACITY_SECOND, TEST_CAPACITY_MAX);
ASSERT_FALSE(ret);
BATTERY_HILOGI(LABEL_TEST, "BatteryService038 function end!");
}
/**
* @tc.name: BatteryService039
* @tc.desc: Test functions GetCapacityLevelInner
* @tc.type: FUNC
*/
static HWTEST_F(BatteryServiceTest, BatteryService039, TestSize.Level1)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryService039 function start!");
if (g_isMock) {
auto tempCapacityThreshold = g_service->shutdownCapacityThreshold_;
g_service->shutdownCapacityThreshold_ = 0;
TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "1");
auto level = g_service->GetCapacityLevelInner();
EXPECT_EQ(level, BatteryCapacityLevel::LEVEL_CRITICAL);
g_service->shutdownCapacityThreshold_ = tempCapacityThreshold;
tempCapacityThreshold = g_service->criticalCapacityThreshold_;
g_service->criticalCapacityThreshold_ = 0;
TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "4");
level = g_service->GetCapacityLevelInner();
EXPECT_EQ(level, BatteryCapacityLevel::LEVEL_WARNING);
g_service->criticalCapacityThreshold_ = tempCapacityThreshold;
tempCapacityThreshold = g_service->warningCapacityThreshold_;
g_service->warningCapacityThreshold_ = 0;
TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "10");
level = g_service->GetCapacityLevelInner();
EXPECT_EQ(level, BatteryCapacityLevel::LEVEL_LOW);
g_service->warningCapacityThreshold_ = tempCapacityThreshold;
tempCapacityThreshold = g_service->lowCapacityThreshold_;
g_service->lowCapacityThreshold_ = 0;
TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "15");
level = g_service->GetCapacityLevelInner();
EXPECT_EQ(level, BatteryCapacityLevel::LEVEL_NORMAL);
g_service->lowCapacityThreshold_ = tempCapacityThreshold;
tempCapacityThreshold = g_service->normalCapacityThreshold_;
g_service->normalCapacityThreshold_ = 0;
TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "90");
level = g_service->GetCapacityLevelInner();
EXPECT_EQ(level, BatteryCapacityLevel::LEVEL_HIGH);
g_service->normalCapacityThreshold_ = tempCapacityThreshold;
tempCapacityThreshold = g_service->highCapacityThreshold_;
g_service->highCapacityThreshold_ = 0;
TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "99");
level = g_service->GetCapacityLevelInner();
EXPECT_EQ(level, BatteryCapacityLevel::LEVEL_FULL);
g_service->highCapacityThreshold_ = tempCapacityThreshold;
tempCapacityThreshold = g_service->fullCapacityThreshold_;
g_service->fullCapacityThreshold_ = 0;
TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "100");
level = g_service->GetCapacityLevelInner();
EXPECT_EQ(level, BatteryCapacityLevel::LEVEL_NONE);
g_service->fullCapacityThreshold_ = tempCapacityThreshold;
TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "50");
}
BATTERY_HILOGI(LABEL_TEST, "BatteryService039 function end!");
}
/**
* @tc.name: BatteryService040
* @tc.desc: Test functions SetBatteryConfig
* @tc.type: FUNC
*/
static HWTEST_F(BatteryServiceTest, BatteryService040, TestSize.Level1)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryService040 function start!");
string sceneName = "testScene";
string value = "";
int32_t batteryErr = static_cast<int32_t>(BatteryError::ERR_FAILURE);
g_service->SetBatteryConfig(sceneName, value, batteryErr);
EXPECT_EQ(batteryErr, static_cast<int32_t>(BatteryError::ERR_SYSTEM_API_DENIED));
BATTERY_HILOGI(LABEL_TEST, "BatteryService040 function end!");
}
/**
* @tc.name: BatteryService041
* @tc.desc: Test functions GetBatteryConfig
* @tc.type: FUNC
*/
static HWTEST_F(BatteryServiceTest, BatteryService041, TestSize.Level1)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryService041 function start!");
string sceneName = "testScene";
string result = "";
int32_t batteryErr = static_cast<int32_t>(BatteryError::ERR_FAILURE);
g_service->GetBatteryConfig(sceneName, result, batteryErr);
EXPECT_EQ(batteryErr, static_cast<int32_t>(BatteryError::ERR_FAILURE));
BATTERY_HILOGI(LABEL_TEST, "BatteryService041 function end!");
}
/**
* @tc.name: BatteryXCollie001
* @tc.desc: Test functions BatteryXCollie default
* @tc.type: FUNC
*/
HWTEST_F(BatteryServiceTest, BatteryXCollie001, TestSize.Level1)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryXCollie001 function start!");
BatteryXCollie batteryXCollie("BatteryService::SetBatteryConfig");
EXPECT_FALSE(batteryXCollie.isCanceled_);
batteryXCollie.CancelBatteryXCollie();
EXPECT_TRUE(batteryXCollie.isCanceled_);
BATTERY_HILOGI(LABEL_TEST, "BatteryXCollie001 function end!");
}
/**
* @tc.name: BatteryXCollie002
* @tc.desc: Test functions BatteryXCollie isRecovery=true
* @tc.type: FUNC
*/
HWTEST_F(BatteryServiceTest, BatteryXCollie002, TestSize.Level1)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryXCollie002 function start!");
BatteryXCollie batteryXCollie("BatteryService::SetBatteryConfig", true);
EXPECT_FALSE(batteryXCollie.isCanceled_);
batteryXCollie.CancelBatteryXCollie();
EXPECT_TRUE(batteryXCollie.isCanceled_);
BATTERY_HILOGI(LABEL_TEST, "BatteryXCollie002 function end!");
}
/**
* @tc.name: BatteryXCollie003
* @tc.desc: Test functions BatteryXCollie logtag empty
* @tc.type: FUNC
*/
HWTEST_F(BatteryServiceTest, BatteryXCollie003, TestSize.Level1)
{
BATTERY_HILOGI(LABEL_TEST, "BatteryXCollie003 function start!");
std::string emptyString;
BatteryXCollie batteryXCollie(emptyString);
EXPECT_FALSE(batteryXCollie.isCanceled_);
batteryXCollie.CancelBatteryXCollie();
EXPECT_TRUE(batteryXCollie.isCanceled_);
BATTERY_HILOGI(LABEL_TEST, "BatteryXCollie003 function end!");
}
utils/native/include/battery_log.h
+2
View File
@@ -16,6 +16,8 @@
#ifndef BATTERY_LOG_H
#define BATTERY_LOG_H
#include <cstdint>
#include "hilog/log.h"
namespace OHOS {
services/zidl/ibattery_srv.zidl → utils/native/include/battery_xcollie.h
Executable → Regular
+27 -5
View File
@@ -1,6 +1,5 @@
/*
* Copyright 2021 Huawei Device Co., Ltd.
*
* Copyright (c) 2025 Huawei Device Co., Ltd.
* 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
@@ -14,6 +13,29 @@
* limitations under the License.
*/
interface OhOs.PowerMgr.IBatterySrv {
/* the function about BatteryService */
}
#ifndef BATTERY_XCOLLIE_H
#define BATTERY_XCOLLIE_H
#include <functional>
#include <string>
#include <atomic>
namespace OHOS {
namespace PowerMgr {
class BatteryXCollie {
public:
BatteryXCollie(const std::string &logTag, bool isRecovery = false);
~BatteryXCollie();
private:
void CancelBatteryXCollie();
int32_t id_;
std::string logTag_;
std::atomic_bool isCanceled_ = false;
};
} // namespace PowerMgr
} // namespace OHOS
#endif // BATTERY_XCOLLIE_H
utils/native/src/battery_xcollie.cpp
+53
View File
@@ -0,0 +1,53 @@
/*
* Copyright (c) 2025 Huawei Device Co., Ltd.
* 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
* limitations under the License.
*/
#include "battery_log.h"
#include "battery_xcollie.h"
#include "xcollie/xcollie.h"
namespace OHOS {
namespace PowerMgr {
BatteryXCollie::BatteryXCollie(const std::string &logTag, bool isRecovery)
{
logTag_ = logTag;
isCanceled_.store(false, std::memory_order_release);
const int DFX_DELAY_S = 60;
unsigned int flag = HiviewDFX::XCOLLIE_FLAG_LOG;
if (isRecovery) {
flag = HiviewDFX::XCOLLIE_FLAG_LOG | HiviewDFX::XCOLLIE_FLAG_RECOVERY;
}
id_ = HiviewDFX::XCollie::GetInstance().SetTimer(logTag_, DFX_DELAY_S, nullptr, nullptr, flag);
if (id_ == HiviewDFX::INVALID_ID) {
BATTERY_HILOGE(COMP_SVC, "Start BatteryXCollie SetTimer fail, tag:%{public}s, timeout(s):%{public}u",
logTag_.c_str(), DFX_DELAY_S);
return;
}
BATTERY_HILOGD(COMP_SVC, "Start BatteryXCollie, id:%{public}d, tag:%{public}s, timeout(s):%{public}u", id_,
logTag_.c_str(), DFX_DELAY_S);
}
BatteryXCollie::~BatteryXCollie()
{
CancelBatteryXCollie();
}
void BatteryXCollie::CancelBatteryXCollie()
{
if (isCanceled_.load(std::memory_order_acquire)) {
return;
}
if (id_ != HiviewDFX::INVALID_ID) {
HiviewDFX::XCollie::GetInstance().CancelTimer(id_);
id_ = HiviewDFX::INVALID_ID;
}
isCanceled_.store(true, std::memory_order_release);
BATTERY_HILOGD(COMP_SVC, "Cancel BatteryXCollie, id:%{public}d, tag:%{public}s", id_, logTag_.c_str());
}
} // namespace PowerMgr
} // namespace OHOS