diff --git a/bundle.json b/bundle.json index 83c1ded1..287b5ffa 100644 --- a/bundle.json +++ b/bundle.json @@ -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" } diff --git a/frameworks/native/src/battery_srv_client.cpp b/frameworks/native/src/battery_srv_client.cpp index a1680dd9..3aec4435 100644 --- a/frameworks/native/src/battery_srv_client.cpp +++ b/frameworks/native/src/battery_srv_client.cpp @@ -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(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(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(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(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(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(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(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); } 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(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(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(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(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(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(batteryErr); } } // namespace PowerMgr } // namespace OHOS diff --git a/interfaces/inner_api/BUILD.gn b/interfaces/inner_api/BUILD.gn index f453d5e9..c9ef8a20 100755 --- a/interfaces/inner_api/BUILD.gn +++ b/interfaces/inner_api/BUILD.gn @@ -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", ] diff --git a/interfaces/inner_api/native/include/battery_manager_ipc_interface_code.h b/interfaces/inner_api/native/include/battery_manager_ipc_interface_code.h deleted file mode 100644 index 662c1d3a..00000000 --- a/interfaces/inner_api/native/include/battery_manager_ipc_interface_code.h +++ /dev/null @@ -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 diff --git a/interfaces/inner_api/native/include/battery_srv_client.h b/interfaces/inner_api/native/include/battery_srv_client.h index 6b2931a8..e3391116 100755 --- a/interfaces/inner_api/native/include/battery_srv_client.h +++ b/interfaces/inner_api/native/include/battery_srv_client.h @@ -19,6 +19,8 @@ #include #include #include +#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(); diff --git a/interfaces/inner_api/native/include/ibattery_srv.h b/interfaces/inner_api/native/include/ibattery_srv.h deleted file mode 100755 index 9749f81f..00000000 --- a/interfaces/inner_api/native/include/ibattery_srv.h +++ /dev/null @@ -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 -#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 diff --git a/services/BUILD.gn b/services/BUILD.gn index 0288660f..82419afd 100644 --- a/services/BUILD.gn +++ b/services/BUILD.gn @@ -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", diff --git a/services/native/include/battery_dump.h b/services/native/include/battery_dump.h index c18db59a..1b6f956f 100644 --- a/services/native/include/battery_dump.h +++ b/services/native/include/battery_dump.h @@ -36,6 +36,7 @@ public: bool Reset(int32_t fd, sptr &service, const std::vector &args); bool MockCapacity(int32_t fd, sptr &service, const std::vector &args); bool MockUevent(int32_t fd, sptr &service, const std::vector &args); + void DumpBatteryInfo(sptr &service, int32_t fd); private: void DumpCurrentTime(int32_t fd); diff --git a/services/native/include/battery_service.h b/services/native/include/battery_service.h index b5befba2..60530a67 100755 --- a/services/native/include/battery_service.h +++ b/services/native/include/battery_service.h @@ -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 &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_; diff --git a/services/native/src/battery_dump.cpp b/services/native/src/battery_dump.cpp index 6e971eec..198254a6 100644 --- a/services/native/src/battery_dump.cpp +++ b/services/native/src/battery_dump.cpp @@ -59,6 +59,54 @@ void BatteryDump::DumpCurrentTime(int32_t fd) int32_t { (curTime.tv_nsec / MS_NS) }); } +void BatteryDump::DumpBatteryInfo(sptr &service, int32_t fd) +{ + int32_t capacity = 0; + service->GetCapacity(capacity); + dprintf(fd, "capacity: %d \n", capacity); + uint32_t batteryLevel = static_cast(BatteryCapacityLevel::LEVEL_NONE); + service->GetCapacityLevel(batteryLevel); + dprintf(fd, "batteryLevel: %u \n", batteryLevel); + uint32_t chargingStatus = static_cast(BatteryChargeState::CHARGE_STATE_NONE); + service->GetChargingStatus(chargingStatus); + dprintf(fd, "chargingStatus: %u \n", chargingStatus); + uint32_t healthState = static_cast(BatteryHealthState::HEALTH_STATE_UNKNOWN); + service->GetHealthStatus(healthState); + dprintf(fd, "healthState: %u \n", healthState); + uint32_t pluggedType = static_cast(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 &service, const std::vector &args) { if ((args.empty()) || (args[0].compare(u"-i") != 0)) { @@ -66,36 +114,7 @@ bool BatteryDump::GetBatteryInfo(int32_t fd, sptr &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; } diff --git a/services/native/src/battery_notify.cpp b/services/native/src/battery_notify.cpp index ff1db873..0f190295 100644 --- a/services/native/src/battery_notify.cpp +++ b/services/native/src/battery_notify.cpp @@ -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(BatteryCapacityLevel::LEVEL_NONE); + g_service->GetCapacityLevel(capacityLevel); + if (static_cast(capacityLevel) != g_lastCapacityLevel) { want.SetParam(BatteryInfo::COMMON_EVENT_KEY_CAPACITY_LEVEL, static_cast(capacityLevel)); - g_lastCapacityLevel = capacityLevel; + g_lastCapacityLevel = static_cast(capacityLevel); } want.SetAction(CommonEventSupport::COMMON_EVENT_BATTERY_CHANGED); diff --git a/services/native/src/battery_service.cpp b/services/native/src/battery_service.cpp index e6923c40..7a0e38ef 100644 --- a/services/native/src/battery_service.cpp +++ b/services/native/src/battery_service.cpp @@ -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 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 lock(mutex_); if (iBatteryInterface_ == nullptr) { @@ -719,7 +719,7 @@ int32_t BatteryService::GetVoltage() return voltage; } -bool BatteryService::GetPresent() +bool BatteryService::GetPresentInner() { std::shared_lock 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 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 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 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 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(GetChargingStatusInner()); + return ERR_OK; +} + +int32_t BatteryService::GetHealthStatus(uint32_t& healthState) +{ + BatteryXCollie batteryXCollie("BatteryService::GetHealthStatus"); + healthState = static_cast(GetHealthStatusInner()); + return ERR_OK; +} + +int32_t BatteryService::GetPluggedType(uint32_t& pluggedType) +{ + BatteryXCollie batteryXCollie("BatteryService::GetPluggedType"); + pluggedType = static_cast(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(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(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(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(IsBatteryConfigSupportedInner(featureName, result)); + return ERR_OK; +} } // namespace PowerMgr } // namespace OHOS diff --git a/services/zidl/BUILD.gn b/services/zidl/BUILD.gn index a8f59065..3582c5b4 100644 --- a/services/zidl/BUILD.gn +++ b/services/zidl/BUILD.gn @@ -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" diff --git a/services/zidl/IBatterySrv.idl b/services/zidl/IBatterySrv.idl new file mode 100644 index 00000000..f2df01a8 --- /dev/null +++ b/services/zidl/IBatterySrv.idl @@ -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); +} \ No newline at end of file diff --git a/services/zidl/include/battery_srv_proxy.h b/services/zidl/include/battery_srv_proxy.h deleted file mode 100755 index 06aa4403..00000000 --- a/services/zidl/include/battery_srv_proxy.h +++ /dev/null @@ -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 -#include -#include -#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 { -public: - explicit BatterySrvProxy(const sptr& impl) - : IRemoteProxy(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 delegator_; -}; -} // namespace PowerMgr -} // namespace OHOS - -#endif // BATTERY_SRV_PROXY_H diff --git a/services/zidl/include/battery_srv_stub.h b/services/zidl/include/battery_srv_stub.h deleted file mode 100755 index 5e38da13..00000000 --- a/services/zidl/include/battery_srv_stub.h +++ /dev/null @@ -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 -#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 { -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 diff --git a/services/zidl/src/battery_srv_proxy.cpp b/services/zidl/src/battery_srv_proxy.cpp deleted file mode 100755 index 5bf8e64c..00000000 --- a/services/zidl/src/battery_srv_proxy.cpp +++ /dev/null @@ -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 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(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 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(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(BatteryChargeState::CHARGE_STATE_BUTT); - RETURN_IF_READ_PARCEL_FAILED_WITH_RET(reply, Uint32, chargingState, BatteryChargeState::CHARGE_STATE_BUTT); - return static_cast(chargingState); -} - -BatteryHealthState BatterySrvProxy::GetHealthStatus() -{ - sptr 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(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(BatteryHealthState::HEALTH_STATE_BUTT); - RETURN_IF_READ_PARCEL_FAILED_WITH_RET(reply, Uint32, healthStatus, BatteryHealthState::HEALTH_STATE_BUTT); - return static_cast(healthStatus); -} - -BatteryPluggedType BatterySrvProxy::GetPluggedType() -{ - sptr 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(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(BatteryPluggedType::PLUGGED_TYPE_BUTT); - RETURN_IF_READ_PARCEL_FAILED_WITH_RET(reply, Uint32, pluggedType, BatteryPluggedType::PLUGGED_TYPE_BUTT); - return static_cast(pluggedType); -} - -int32_t BatterySrvProxy::GetVoltage() -{ - sptr 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(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 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(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 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(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 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(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 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(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(BatteryCapacityLevel::LEVEL_NONE); - RETURN_IF_READ_PARCEL_FAILED_WITH_RET(reply, Uint32, level, BatteryCapacityLevel::LEVEL_NONE); - return static_cast(level); -} - -int64_t BatterySrvProxy::GetRemainingChargeTime() -{ - sptr 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(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 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(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 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(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 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(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 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(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 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(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(error); -} - -BatteryError BatterySrvProxy::GetBatteryConfig(const std::string& sceneName, std::string& result) -{ - sptr 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(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(error); -} - -BatteryError BatterySrvProxy::IsBatteryConfigSupported(const std::string& sceneName, bool& result) -{ - sptr 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(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(error); -} -} // namespace PowerMgr -} // namespace OHOS diff --git a/services/zidl/src/battery_srv_stub.cpp b/services/zidl/src/battery_srv_stub.cpp deleted file mode 100755 index e8b7a247..00000000 --- a/services/zidl/src/battery_srv_stub.cpp +++ /dev/null @@ -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(PowerMgr::BatterySrvInterfaceCode::BATT_GET_CAPACITY): - return GetCapacityStub(reply); - case static_cast(PowerMgr::BatterySrvInterfaceCode::BATT_GET_CHARGING_STATUS): - return GetChargingStatusStub(reply); - case static_cast(PowerMgr::BatterySrvInterfaceCode::BATT_GET_HEALTH_STATUS): - return GetHealthStatusStub(reply); - case static_cast(PowerMgr::BatterySrvInterfaceCode::BATT_GET_PLUG_TYPE): - return GetPluggedTypeStub(reply); - case static_cast(PowerMgr::BatterySrvInterfaceCode::BATT_GET_VOLTAGE): - return GetVoltageStub(reply); - case static_cast(PowerMgr::BatterySrvInterfaceCode::BATT_GET_PRESENT): - return GetPresentStub(reply); - case static_cast(PowerMgr::BatterySrvInterfaceCode::BATT_GET_TEMPERATURE): - return GetBatteryTemperatureStub(reply); - case static_cast(PowerMgr::BatterySrvInterfaceCode::BATT_GET_BATTERY_LEVEL): - return GetBatteryCapacityLevelStub(reply); - case static_cast(PowerMgr::BatterySrvInterfaceCode::BATT_GET_REMAINING_CHARGE_TIME): - return GetRemainingChargeTimeStub(reply); - case static_cast(PowerMgr::BatterySrvInterfaceCode::BATT_GET_TECHNOLOGY): - return GetTechnologyStub(reply); - case static_cast(PowerMgr::BatterySrvInterfaceCode::BATT_GET_BATTERY_CURRENT_NOW): - return GetNowCurrentStub(reply); - case static_cast(PowerMgr::BatterySrvInterfaceCode::BATT_GET_BATTERY_REMAIN_ENERGY): - return GetRemainEnergyStub(reply); - case static_cast(PowerMgr::BatterySrvInterfaceCode::BATT_GET_BATTERY_TOTAL_ENERGY): - return GetTotalEnergyStub(reply); - case static_cast(PowerMgr::BatterySrvInterfaceCode::BATT_GET_BATTERY_CURRENT_AVERAGE): - return GetCurrentAverageStub(reply); - case static_cast(PowerMgr::BatterySrvInterfaceCode::SET_BATTERY_CONFIG): - return SetChargeConfigStub(data, reply); - case static_cast(PowerMgr::BatterySrvInterfaceCode::GET_BATTERY_CONFIG): - return GetChargeConfigStub(data, reply); - case static_cast(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(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(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(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(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(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(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(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 diff --git a/test/benchmarktest/BUILD.gn b/test/benchmarktest/BUILD.gn index f89b9728..1baa9b5b 100644 --- a/test/benchmarktest/BUILD.gn +++ b/test/benchmarktest/BUILD.gn @@ -25,6 +25,8 @@ ohos_benchmarktest("BatteryBenchmarkTest") { "ipc:ipc_core", ] + external_deps += [ "hilog:libhilog" ] + cflags = [ "-Wall", "-Wextra", diff --git a/test/fuzztest/getbatteryconfig_fuzzer/getbatteryconfig_fuzzer_test.cpp b/test/fuzztest/getbatteryconfig_fuzzer/getbatteryconfig_fuzzer_test.cpp index ed6e667c..ade0b8e6 100644 --- a/test/fuzztest/getbatteryconfig_fuzzer/getbatteryconfig_fuzzer_test.cpp +++ b/test/fuzztest/getbatteryconfig_fuzzer/getbatteryconfig_fuzzer_test.cpp @@ -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(BatterySrvInterfaceCode::GET_BATTERY_CONFIG), data, size); + static_cast(IBatterySrvIpcCode::COMMAND_GET_BATTERY_CONFIG), data, size); return 0; } diff --git a/test/fuzztest/getbatterytemperature_fuzzer/getbatterytemperature_fuzzer_test.cpp b/test/fuzztest/getbatterytemperature_fuzzer/getbatterytemperature_fuzzer_test.cpp index 92c94e49..f88bd852 100644 --- a/test/fuzztest/getbatterytemperature_fuzzer/getbatterytemperature_fuzzer_test.cpp +++ b/test/fuzztest/getbatterytemperature_fuzzer/getbatterytemperature_fuzzer_test.cpp @@ -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(BatterySrvInterfaceCode::BATT_GET_TEMPERATURE), data, size); + static_cast(IBatterySrvIpcCode::COMMAND_GET_BATTERY_TEMPERATURE), data, size); return 0; } diff --git a/test/fuzztest/getcapacity_fuzzer/getcapacity_fuzzer_test.cpp b/test/fuzztest/getcapacity_fuzzer/getcapacity_fuzzer_test.cpp index c0805729..9cec82a8 100644 --- a/test/fuzztest/getcapacity_fuzzer/getcapacity_fuzzer_test.cpp +++ b/test/fuzztest/getcapacity_fuzzer/getcapacity_fuzzer_test.cpp @@ -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(BatterySrvInterfaceCode::BATT_GET_CAPACITY), data, size); + g_serviceTest.TestBatteryServiceStub( + static_cast(IBatterySrvIpcCode::COMMAND_GET_CAPACITY), data, size); return 0; } diff --git a/test/fuzztest/getcapacitylevel_fuzzer/getcapacitylevel_fuzzer_test.cpp b/test/fuzztest/getcapacitylevel_fuzzer/getcapacitylevel_fuzzer_test.cpp index faeb3ddb..9c6dc83a 100644 --- a/test/fuzztest/getcapacitylevel_fuzzer/getcapacitylevel_fuzzer_test.cpp +++ b/test/fuzztest/getcapacitylevel_fuzzer/getcapacitylevel_fuzzer_test.cpp @@ -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(BatterySrvInterfaceCode::BATT_GET_BATTERY_LEVEL), data, size); + static_cast(IBatterySrvIpcCode::COMMAND_GET_CAPACITY_LEVEL), data, size); return 0; } diff --git a/test/fuzztest/getchargingstatus_fuzzer/getchargingstatus_fuzzer_test.cpp b/test/fuzztest/getchargingstatus_fuzzer/getchargingstatus_fuzzer_test.cpp index ce4637d5..685fa32e 100644 --- a/test/fuzztest/getchargingstatus_fuzzer/getchargingstatus_fuzzer_test.cpp +++ b/test/fuzztest/getchargingstatus_fuzzer/getchargingstatus_fuzzer_test.cpp @@ -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(BatterySrvInterfaceCode::BATT_GET_CHARGING_STATUS), data, size); + static_cast(IBatterySrvIpcCode::COMMAND_GET_CHARGING_STATUS), data, size); return 0; } diff --git a/test/fuzztest/getcurrentaverage_fuzzer/getcurrentaverage_fuzzer_test.cpp b/test/fuzztest/getcurrentaverage_fuzzer/getcurrentaverage_fuzzer_test.cpp index 9b5b821a..e15110f7 100644 --- a/test/fuzztest/getcurrentaverage_fuzzer/getcurrentaverage_fuzzer_test.cpp +++ b/test/fuzztest/getcurrentaverage_fuzzer/getcurrentaverage_fuzzer_test.cpp @@ -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(BatterySrvInterfaceCode::BATT_GET_BATTERY_CURRENT_AVERAGE), data, size); + static_cast(IBatterySrvIpcCode::COMMAND_GET_CURRENT_AVERAGE), data, size); return 0; } diff --git a/test/fuzztest/gethealthstatus_fuzzer/gethealthstatus_fuzzer_test.cpp b/test/fuzztest/gethealthstatus_fuzzer/gethealthstatus_fuzzer_test.cpp index 3bcb92d7..ff8469db 100644 --- a/test/fuzztest/gethealthstatus_fuzzer/gethealthstatus_fuzzer_test.cpp +++ b/test/fuzztest/gethealthstatus_fuzzer/gethealthstatus_fuzzer_test.cpp @@ -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(BatterySrvInterfaceCode::BATT_GET_HEALTH_STATUS), data, size); + static_cast(IBatterySrvIpcCode::COMMAND_GET_HEALTH_STATUS), data, size); return 0; } diff --git a/test/fuzztest/getnowcurrent_fuzzer/getnowcurrent_fuzzer_test.cpp b/test/fuzztest/getnowcurrent_fuzzer/getnowcurrent_fuzzer_test.cpp index 7cc57fcc..1c12994f 100644 --- a/test/fuzztest/getnowcurrent_fuzzer/getnowcurrent_fuzzer_test.cpp +++ b/test/fuzztest/getnowcurrent_fuzzer/getnowcurrent_fuzzer_test.cpp @@ -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(BatterySrvInterfaceCode::BATT_GET_BATTERY_CURRENT_NOW), data, size); + static_cast(IBatterySrvIpcCode::COMMAND_GET_NOW_CURRENT), data, size); return 0; } diff --git a/test/fuzztest/getpluggedtype_fuzzer/getpluggedtype_fuzzer_test.cpp b/test/fuzztest/getpluggedtype_fuzzer/getpluggedtype_fuzzer_test.cpp index 0a3ca460..5475c21c 100644 --- a/test/fuzztest/getpluggedtype_fuzzer/getpluggedtype_fuzzer_test.cpp +++ b/test/fuzztest/getpluggedtype_fuzzer/getpluggedtype_fuzzer_test.cpp @@ -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(BatterySrvInterfaceCode::BATT_GET_PLUG_TYPE), data, size); + static_cast(IBatterySrvIpcCode::COMMAND_GET_PLUGGED_TYPE), data, size); return 0; } diff --git a/test/fuzztest/getpresent_fuzzer/getpresent_fuzzer_test.cpp b/test/fuzztest/getpresent_fuzzer/getpresent_fuzzer_test.cpp index 100b3e90..8f44b078 100644 --- a/test/fuzztest/getpresent_fuzzer/getpresent_fuzzer_test.cpp +++ b/test/fuzztest/getpresent_fuzzer/getpresent_fuzzer_test.cpp @@ -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(BatterySrvInterfaceCode::BATT_GET_PRESENT), data, size); + g_serviceTest.TestBatteryServiceStub( + static_cast(IBatterySrvIpcCode::COMMAND_GET_PRESENT), data, size); return 0; } diff --git a/test/fuzztest/getremainenergy_fuzzer/getremainenergy_fuzzer_test.cpp b/test/fuzztest/getremainenergy_fuzzer/getremainenergy_fuzzer_test.cpp index 13de8864..ac5797ec 100644 --- a/test/fuzztest/getremainenergy_fuzzer/getremainenergy_fuzzer_test.cpp +++ b/test/fuzztest/getremainenergy_fuzzer/getremainenergy_fuzzer_test.cpp @@ -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(BatterySrvInterfaceCode::BATT_GET_BATTERY_REMAIN_ENERGY), data, size); + static_cast(IBatterySrvIpcCode::COMMAND_GET_REMAIN_ENERGY), data, size); return 0; } diff --git a/test/fuzztest/getremainingchargetime_fuzzer/getremainingchargetime_fuzzer_test.cpp b/test/fuzztest/getremainingchargetime_fuzzer/getremainingchargetime_fuzzer_test.cpp index cbe4c503..44c070f0 100644 --- a/test/fuzztest/getremainingchargetime_fuzzer/getremainingchargetime_fuzzer_test.cpp +++ b/test/fuzztest/getremainingchargetime_fuzzer/getremainingchargetime_fuzzer_test.cpp @@ -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(BatterySrvInterfaceCode::BATT_GET_REMAINING_CHARGE_TIME), data, size); + static_cast(IBatterySrvIpcCode::COMMAND_GET_REMAINING_CHARGE_TIME), data, size); return 0; } diff --git a/test/fuzztest/gettechnology_fuzzer/gettechnology_fuzzer_test.cpp b/test/fuzztest/gettechnology_fuzzer/gettechnology_fuzzer_test.cpp index 6bd7ed13..5775f429 100644 --- a/test/fuzztest/gettechnology_fuzzer/gettechnology_fuzzer_test.cpp +++ b/test/fuzztest/gettechnology_fuzzer/gettechnology_fuzzer_test.cpp @@ -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(BatterySrvInterfaceCode::BATT_GET_TECHNOLOGY), data, size); + static_cast(IBatterySrvIpcCode::COMMAND_GET_TECHNOLOGY), data, size); return 0; } diff --git a/test/fuzztest/gettotalenergy_fuzzer/gettotalenergy_fuzzer_test.cpp b/test/fuzztest/gettotalenergy_fuzzer/gettotalenergy_fuzzer_test.cpp index d04f193a..f57fb0ea 100644 --- a/test/fuzztest/gettotalenergy_fuzzer/gettotalenergy_fuzzer_test.cpp +++ b/test/fuzztest/gettotalenergy_fuzzer/gettotalenergy_fuzzer_test.cpp @@ -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(BatterySrvInterfaceCode::BATT_GET_BATTERY_TOTAL_ENERGY), data, size); + static_cast(IBatterySrvIpcCode::COMMAND_GET_TOTAL_ENERGY), data, size); return 0; } diff --git a/test/fuzztest/getvoltage_fuzzer/getvoltage_fuzzer_test.cpp b/test/fuzztest/getvoltage_fuzzer/getvoltage_fuzzer_test.cpp index f2da866d..6b68bac4 100644 --- a/test/fuzztest/getvoltage_fuzzer/getvoltage_fuzzer_test.cpp +++ b/test/fuzztest/getvoltage_fuzzer/getvoltage_fuzzer_test.cpp @@ -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(BatterySrvInterfaceCode::BATT_GET_VOLTAGE), data, size); + g_serviceTest.TestBatteryServiceStub( + static_cast(IBatterySrvIpcCode::COMMAND_GET_VOLTAGE), data, size); return 0; } diff --git a/test/fuzztest/isbatteryconfigsupported_fuzzer/isbatteryconfigsupported_fuzzer_test.cpp b/test/fuzztest/isbatteryconfigsupported_fuzzer/isbatteryconfigsupported_fuzzer_test.cpp index ededd0bc..00d905ba 100644 --- a/test/fuzztest/isbatteryconfigsupported_fuzzer/isbatteryconfigsupported_fuzzer_test.cpp +++ b/test/fuzztest/isbatteryconfigsupported_fuzzer/isbatteryconfigsupported_fuzzer_test.cpp @@ -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(BatterySrvInterfaceCode::SUPPORT_BATTERY_CONFIG), data, size); + static_cast(IBatterySrvIpcCode::COMMAND_IS_BATTERY_CONFIG_SUPPORTED), data, size); return 0; } diff --git a/test/fuzztest/setbatteryconfig_fuzzer/setbatteryconfig_fuzzer_test.cpp b/test/fuzztest/setbatteryconfig_fuzzer/setbatteryconfig_fuzzer_test.cpp index 3cadc8ba..b7dcfe19 100644 --- a/test/fuzztest/setbatteryconfig_fuzzer/setbatteryconfig_fuzzer_test.cpp +++ b/test/fuzztest/setbatteryconfig_fuzzer/setbatteryconfig_fuzzer_test.cpp @@ -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(BatterySrvInterfaceCode::SET_BATTERY_CONFIG), data, size); + static_cast(IBatterySrvIpcCode::COMMAND_SET_BATTERY_CONFIG), data, size); return 0; } diff --git a/test/unittest/BUILD.gn b/test/unittest/BUILD.gn index 4662b3d3..d8f5798a 100644 --- a/test/unittest/BUILD.gn +++ b/test/unittest/BUILD.gn @@ -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", ] diff --git a/test/unittest/mock/include/mock_battery_srv_proxy.h b/test/unittest/mock/include/mock_battery_srv_proxy.h new file mode 100644 index 00000000..c74be9ba --- /dev/null +++ b/test/unittest/mock/include/mock_battery_srv_proxy.h @@ -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& 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 diff --git a/test/unittest/mock/source/mock_battery_srv_proxy.cpp b/test/unittest/mock/source/mock_battery_srv_proxy.cpp new file mode 100644 index 00000000..25f9c6e4 --- /dev/null +++ b/test/unittest/mock/source/mock_battery_srv_proxy.cpp @@ -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 diff --git a/test/unittest/src/battert_service_inner_test.cpp b/test/unittest/src/battert_service_inner_test.cpp index 9ca9991c..a79a0b66 100644 --- a/test/unittest/src/battert_service_inner_test.cpp +++ b/test/unittest/src/battert_service_inner_test.cpp @@ -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 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 diff --git a/test/unittest/src/battery_srv_proxy_mock_test.cpp b/test/unittest/src/battery_srv_proxy_mock_test.cpp index 0d8bf549..643af54c 100644 --- a/test/unittest/src/battery_srv_proxy_mock_test.cpp +++ b/test/unittest/src/battery_srv_proxy_mock_test.cpp @@ -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 #endif @@ -32,6 +33,7 @@ using namespace std; namespace { std::shared_ptr g_proxy; sptr 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(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(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(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(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(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(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(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!"); } diff --git a/test/unittest/src/battery_srv_stub_test.cpp b/test/unittest/src/battery_srv_stub_test.cpp index 131f7cc1..4860847f 100644 --- a/test/unittest/src/battery_srv_stub_test.cpp +++ b/test/unittest/src/battery_srv_stub_test.cpp @@ -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(PowerMgr::BatterySrvInterfaceCode::BATT_GET_CAPACITY); - uint32_t end = static_cast(PowerMgr::BatterySrvInterfaceCode::BATT_GET_BATTERY_REMAIN_ENERGY); + uint32_t begin = static_cast(PowerMgr::IBatterySrvIpcCode::COMMAND_GET_CAPACITY); + uint32_t end = static_cast(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(PowerMgr::BatterySrvInterfaceCode::SET_BATTERY_CONFIG); + uint32_t code = static_cast(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(PowerMgr::BatterySrvInterfaceCode::GET_BATTERY_CONFIG); + uint32_t code = static_cast(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(PowerMgr::BatterySrvInterfaceCode::SUPPORT_BATTERY_CONFIG); + uint32_t code = static_cast(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!"); diff --git a/test/unittest/src/interface_test/battery_client_test.cpp b/test/unittest/src/interface_test/battery_client_test.cpp index aba01a05..e670e876 100644 --- a/test/unittest/src/interface_test/battery_client_test.cpp +++ b/test/unittest/src/interface_test/battery_client_test.cpp @@ -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 g_testRemoteObj; +sptr g_mockProxy; } void BatteryClientTest::SetUpTestCase(void) { g_isMock = TestUtils::IsMock(); GTEST_LOG_(INFO) << " g_isMock: " << g_isMock; + g_testRemoteObj = sptr::MakeSptr(u"BatteryTest"); + g_mockProxy = sptr::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 diff --git a/test/unittest/src/interface_test/battery_service_test.cpp b/test/unittest/src/interface_test/battery_service_test.cpp index 78bb7a8a..a6e7bc31 100644 --- a/test/unittest/src/interface_test/battery_service_test.cpp +++ b/test/unittest/src/interface_test/battery_service_test.cpp @@ -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 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(BatteryError::ERR_FAILURE); + bool result = false; + g_service->IsBatteryConfigSupported(sceneName, result, batteryErr); + EXPECT_EQ(batteryErr, static_cast(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(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(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(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(level), BatteryCapacityLevel::LEVEL_SHUTDOWN); + + TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "4"); + g_service->GetCapacityLevel(level); + EXPECT_EQ(static_cast(level), BatteryCapacityLevel::LEVEL_CRITICAL); + + TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "10"); + g_service->GetCapacityLevel(level); + EXPECT_EQ(static_cast(level), BatteryCapacityLevel::LEVEL_WARNING); + + TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "15"); + g_service->GetCapacityLevel(level); + EXPECT_EQ(static_cast(level), BatteryCapacityLevel::LEVEL_LOW); + + TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "90"); + g_service->GetCapacityLevel(level); + EXPECT_EQ(static_cast(level), BatteryCapacityLevel::LEVEL_NORMAL); + + TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "99"); + g_service->GetCapacityLevel(level); + EXPECT_EQ(static_cast(level), BatteryCapacityLevel::LEVEL_HIGH); + + TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "100"); + g_service->GetCapacityLevel(level); + EXPECT_EQ(static_cast(level), BatteryCapacityLevel::LEVEL_FULL); + + TestUtils::WriteMock(MOCK_BATTERY_PATH + "/battery/capacity", "200"); + g_service->GetCapacityLevel(level); + EXPECT_EQ(static_cast(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(BatteryError::ERR_FAILURE); + g_service->SetBatteryConfig(sceneName, value, batteryErr); + EXPECT_EQ(batteryErr, static_cast(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(BatteryError::ERR_FAILURE); + g_service->GetBatteryConfig(sceneName, result, batteryErr); + EXPECT_EQ(batteryErr, static_cast(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!"); +} \ No newline at end of file diff --git a/utils/native/include/battery_log.h b/utils/native/include/battery_log.h index 078f0166..1ce07f05 100644 --- a/utils/native/include/battery_log.h +++ b/utils/native/include/battery_log.h @@ -16,6 +16,8 @@ #ifndef BATTERY_LOG_H #define BATTERY_LOG_H +#include + #include "hilog/log.h" namespace OHOS { diff --git a/services/zidl/ibattery_srv.zidl b/utils/native/include/battery_xcollie.h old mode 100755 new mode 100644 similarity index 51% rename from services/zidl/ibattery_srv.zidl rename to utils/native/include/battery_xcollie.h index a2783b9c..9aa8ca5d --- a/services/zidl/ibattery_srv.zidl +++ b/utils/native/include/battery_xcollie.h @@ -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 */ -} \ No newline at end of file +#ifndef BATTERY_XCOLLIE_H +#define BATTERY_XCOLLIE_H + +#include +#include +#include + +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 diff --git a/utils/native/src/battery_xcollie.cpp b/utils/native/src/battery_xcollie.cpp new file mode 100644 index 00000000..ca039b8a --- /dev/null +++ b/utils/native/src/battery_xcollie.cpp @@ -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 \ No newline at end of file