From 2f559ce3c2d82c1a11e22615a538b48d6a503c84 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=8E=8B=E5=85=B3?= Date: Mon, 28 Apr 2025 16:51:06 +0800 Subject: [PATCH] =?UTF-8?q?style:=20battery=5Fmanager=E4=BB=93IDL=E5=8C=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: yxj --- bundle.json | 3 +- frameworks/native/src/battery_srv_client.cpp | 112 +++- interfaces/inner_api/BUILD.gn | 16 +- .../native/include/battery_srv_client.h | 2 + .../inner_api/native/include/ibattery_srv.h | 52 -- services/BUILD.gn | 2 +- services/native/include/battery_service.h | 54 +- services/native/src/battery_service.cpp | 481 ++++++++++++------ services/zidl/BUILD.gn | 51 +- services/zidl/IBatterySrv.idl | 34 ++ services/zidl/include/battery_srv_proxy.h | 62 --- services/zidl/include/battery_srv_stub.h | 60 --- services/zidl/src/battery_srv_proxy.cpp | 469 ----------------- services/zidl/src/battery_srv_stub.cpp | 228 --------- test/benchmarktest/BUILD.gn | 4 + test/unittest/BUILD.gn | 64 ++- .../src/battery_srv_proxy_mock_test.cpp | 79 ++- 17 files changed, 683 insertions(+), 1090 deletions(-) delete mode 100755 interfaces/inner_api/native/include/ibattery_srv.h create mode 100644 services/zidl/IBatterySrv.idl delete mode 100755 services/zidl/include/battery_srv_proxy.h delete mode 100755 services/zidl/include/battery_srv_stub.h delete mode 100755 services/zidl/src/battery_srv_proxy.cpp delete mode 100755 services/zidl/src/battery_srv_stub.cpp diff --git a/bundle.json b/bundle.json index c58a6c5..19ad9fe 100644 --- a/bundle.json +++ b/bundle.json @@ -96,8 +96,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 a1680dd..ffd678f 100644 --- a/frameworks/native/src/battery_srv_client.cpp +++ b/frameworks/native/src/battery_srv_client.cpp @@ -90,112 +90,192 @@ 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 error ret = %{public}d", ret); + } + return capacity; } BatteryChargeState BatterySrvClient::GetChargingStatus() { auto proxy = Connect(); RETURN_IF_WITH_RET(proxy == nullptr, BatteryChargeState::CHARGE_STATE_BUTT); - return proxy->GetChargingStatus(); + uint32_t chargingStatus = static_cast(BatteryChargeState::CHARGE_STATE_BUTT); + auto ret = proxy->GetChargingStatus(chargingStatus); + if (ret != ERR_OK) { + BATTERY_HILOGE(COMP_FWK, "GetChargingStatus error ret = %{public}d", ret); + } + return BatteryChargeState(chargingStatus); } BatteryHealthState BatterySrvClient::GetHealthStatus() { auto proxy = Connect(); RETURN_IF_WITH_RET(proxy == nullptr, BatteryHealthState::HEALTH_STATE_BUTT); - return proxy->GetHealthStatus(); + uint32_t healthStatus = static_cast(BatteryHealthState::HEALTH_STATE_BUTT); + auto ret = proxy->GetHealthStatus(healthStatus); + if (ret != ERR_OK) { + BATTERY_HILOGE(COMP_FWK, "GetHealthStatus error ret = %{public}d", ret); + } + return BatteryHealthState(healthStatus); } 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 error ret = %{public}d", ret); + } + return BatteryPluggedType(pluggedType); } int32_t BatterySrvClient::GetVoltage() { auto proxy = Connect(); RETURN_IF_WITH_RET(proxy == nullptr, INVALID_BATT_INT_VALUE); - return proxy->GetVoltage(); + int32_t voltage = INVALID_BATT_INT_VALUE; + auto ret = proxy->GetVoltage(voltage); + if (ret != ERR_OK) { + BATTERY_HILOGE(COMP_FWK, "GetVoltage error ret = %{public}d", ret); + } + 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 error ret = %{public}d", ret); + } + return present; } std::string BatterySrvClient::GetTechnology() { auto proxy = Connect(); RETURN_IF_WITH_RET(proxy == nullptr, ""); - return proxy->GetTechnology(); + std::string technology = ""; + auto ret = proxy->GetTechnology(technology); + if (ret != ERR_OK) { + BATTERY_HILOGE(COMP_FWK, "GetTechnology error ret = %{public}d", ret); + } + 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 error ret = %{public}d", ret); + } + return temperature; } int32_t BatterySrvClient::GetNowCurrent() { auto proxy = Connect(); RETURN_IF_WITH_RET(proxy == nullptr, INVALID_BATT_INT_VALUE); - return proxy->GetNowCurrent(); + int32_t nowCurrent = INVALID_BATT_INT_VALUE; + auto ret = proxy->GetNowCurrent(nowCurrent); + if (ret != ERR_OK) { + BATTERY_HILOGE(COMP_FWK, "GetNowCurrent error ret = %{public}d", ret); + } + return nowCurrent; } 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 error ret = %{public}d", ret); + } + 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 error ret = %{public}d", ret); + } + return totalEnergy; } BatteryCapacityLevel BatterySrvClient::GetCapacityLevel() { auto proxy = Connect(); RETURN_IF_WITH_RET(proxy == nullptr, BatteryCapacityLevel::LEVEL_NONE); - return proxy->GetCapacityLevel(); + int32_t level = static_cast(BatteryCapacityLevel::LEVEL_NONE); + auto ret = proxy->GetCapacityLevel(level); + if (ret != ERR_OK) { + BATTERY_HILOGE(COMP_FWK, "GetTotalEnergy error ret = %{public}d", ret); + } + return static_cast(level); } int64_t BatterySrvClient::GetRemainingChargeTime() { auto proxy = Connect(); RETURN_IF_WITH_RET(proxy == nullptr, INVALID_REMAINING_CHARGE_TIME_VALUE); - return proxy->GetRemainingChargeTime(); + int64_t remainChargeTime = INVALID_REMAINING_CHARGE_TIME_VALUE; + auto ret = proxy->GetRemainingChargeTime(remainChargeTime); + if (ret != ERR_OK) { + BATTERY_HILOGE(COMP_FWK, "GetRemainingChargeTime error ret = %{public}d", ret); + } + return remainChargeTime; } 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 errCode = ERR_OK; + auto ret = proxy->SetBatteryConfig(sceneName, value, errCode); + if (ret != ERR_OK) { + BATTERY_HILOGE(COMP_FWK, "GetBatteryConfig error ret = %{public}d", ret); + } + return BatteryError(errCode); } 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 errCode = ERR_OK; + auto ret = proxy->GetBatteryConfig(sceneName, result, errCode); + if (ret != ERR_OK) { + BATTERY_HILOGE(COMP_FWK, "GetBatteryConfig error ret = %{public}d", ret); + } + return BatteryError(errCode); } 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 errCode = ERR_OK; + auto ret = proxy->IsBatteryConfigSupported(sceneName, result, errCode); + if (ret != ERR_OK) { + BATTERY_HILOGE(COMP_FWK, "GetCapacity error ret = %{public}d", ret); + } + return BatteryError(errCode); } } // namespace PowerMgr } // namespace OHOS diff --git a/interfaces/inner_api/BUILD.gn b/interfaces/inner_api/BUILD.gn index f453d5e..177029d 100755 --- a/interfaces/inner_api/BUILD.gn +++ b/interfaces/inner_api/BUILD.gn @@ -16,22 +16,30 @@ import("../../batterymgr.gni") config("batterysrv_public_config") { include_dirs = [ "native/include", - "${battery_service_zidl}/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", ] - - configs = [ "${battery_utils}:coverage_flags" ] + deps = [ "${battery_service_zidl}:batterysrv_proxy" ] + configs = [ + "${battery_utils}:coverage_flags", + "${battery_service}:batterysrv_public_config", + ] public_configs = [ "${battery_utils}:utils_config", + "${battery_service}:batterysrv_public_config", ":batterysrv_public_config", ] diff --git a/interfaces/inner_api/native/include/battery_srv_client.h b/interfaces/inner_api/native/include/battery_srv_client.h index 6b2931a..8621f3b 100755 --- a/interfaces/inner_api/native/include/battery_srv_client.h +++ b/interfaces/inner_api/native/include/battery_srv_client.h @@ -21,6 +21,8 @@ #include #include "iremote_object.h" #include "ibattery_srv.h" +#include "battery_srv_errors.h" +#include "battery_info.h" namespace OHOS { namespace PowerMgr { 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 9749f81..0000000 --- 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 7bb6c9e..cfdb45a 100644 --- a/services/BUILD.gn +++ b/services/BUILD.gn @@ -17,8 +17,8 @@ config("batterysrv_public_config") { include_dirs = [ "native/include", "native/notification", - "${battery_service_zidl}/include", "${battery_inner_api}/native/include", + "${target_gen_dir}/zidl", ] } diff --git a/services/native/include/battery_service.h b/services/native/include/battery_service.h index b5befba..48f1512 100755 --- a/services/native/include/battery_service.h +++ b/services/native/include/battery_service.h @@ -38,6 +38,7 @@ #include "sp_singleton.h" #include "v2_0/ibattery_interface.h" #include "v2_0/types.h" +#include "battery_srv_errors.h" namespace OHOS { namespace PowerMgr { @@ -61,26 +62,45 @@ public: return isBootCompleted_.load(); } + int32_t GetCapacity(int32_t& capacity) override; + int32_t GetChargingStatus(uint32_t& chargingState) override; + int32_t GetHealthStatus(uint32_t& healthStatus) 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& currentAverage) override; + int32_t GetNowCurrent(int32_t& nowCurrent) override; + int32_t GetRemainEnergy(int32_t& remainEnergy) override; + int32_t GetBatteryTemperature(int32_t& temperature) override; + int32_t GetCapacityLevel(int32_t& level) override; + int32_t GetRemainingChargeTime(int64_t& time) override; + int32_t SetBatteryConfig(const std::string& sceneName, const std::string& sceneValue, + int32_t& errorCode) override; + int32_t GetBatteryConfig(const std::string& sceneName, std::string& sceneValue, int32_t& errorCode) override; + int32_t IsBatteryConfigSupported(const std::string& sceneName, bool& isSupported, int32_t& errorCode) override; + 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; + int32_t GetCapacity(); + BatteryChargeState GetChargingStatus(); + BatteryHealthState GetHealthStatus(); + BatteryPluggedType GetPluggedType(); + int32_t GetVoltage(); + bool GetPresent(); + std::string GetTechnology(); + int32_t GetTotalEnergy(); + int32_t GetCurrentAverage(); + int32_t GetNowCurrent(); + int32_t GetRemainEnergy(); + int32_t GetBatteryTemperature(); + BatteryCapacityLevel GetCapacityLevel(); + int64_t GetRemainingChargeTime(); 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; + BatteryError SetBatteryConfig(const std::string& sceneName, const std::string& value); + BatteryError GetBatteryConfig(const std::string& sceneName, std::string& result); + BatteryError IsBatteryConfigSupported(const std::string& sceneName, bool& result); void InitConfig(); void HandleTemperature(int32_t temperature); bool RegisterHdiStatusListener(); diff --git a/services/native/src/battery_service.cpp b/services/native/src/battery_service.cpp index 8012e2b..406b99b 100644 --- a/services/native/src/battery_service.cpp +++ b/services/native/src/battery_service.cpp @@ -546,17 +546,11 @@ void BatteryService::UnlockShutdownGuard() int32_t BatteryService::GetCapacity() { - if (isMockCapacity_) { - BATTERY_HILOGD(FEATURE_BATT_INFO, "Return mock battery capacity"); - return batteryInfo_.GetCapacity(); - } - std::shared_lock lock(mutex_); int32_t capacity = BATTERY_FULL_CAPACITY; - if (iBatteryInterface_ == nullptr) { - BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr"); - return capacity; + auto ret = GetCapacity(capacity); + if (ret != ERR_OK) { + BATTERY_HILOGE(FEATURE_BATT_INFO, "GetCapacity error, ret = %{public}d", ret); } - iBatteryInterface_->GetCapacity(capacity); return capacity; } @@ -588,216 +582,141 @@ void BatteryService::SetLowCapacityThreshold() BatteryError BatteryService::SetBatteryConfig(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"); - return BatteryError::ERR_SYSTEM_API_DENIED; - } - - BATTERY_HILOGI(FEATURE_BATT_INFO, "Enter SetBatteryConfig sceneName:%{public}s value:%{public}s", - sceneName.c_str(), value.c_str()); - std::shared_lock lock(mutex_); - if (iBatteryInterface_ == nullptr) { - BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr"); - return BatteryError::ERR_FAILURE; + int32_t errCode = static_cast(BatteryError::ERR_OK); + auto ret = SetBatteryConfig(sceneName, value, errCode); + if (ret != ERR_OK) { + BATTERY_HILOGE(FEATURE_BATT_INFO, "SetBatteryConfig error, ret = %{public}d", ret); } - return iBatteryInterface_->SetBatteryConfig(sceneName, value) == ERR_OK ? - BatteryError::ERR_OK : BatteryError::ERR_FAILURE; + return BatteryError(errCode); } BatteryError BatteryService::GetBatteryConfig(const std::string& sceneName, std::string& result) { - if (!Permission::IsSystem()) { - BATTERY_HILOGI(FEATURE_BATT_INFO, "GetBatteryConfig failed, System permission intercept"); - return BatteryError::ERR_SYSTEM_API_DENIED; - } - - BATTERY_HILOGD(FEATURE_BATT_INFO, "Enter GetBatteryConfig"); - std::shared_lock lock(mutex_); - if (iBatteryInterface_ == nullptr) { - BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr"); - return BatteryError::ERR_FAILURE; - } - - int32_t ret = iBatteryInterface_->GetBatteryConfig(sceneName, result); + int32_t errCode = static_cast(BatteryError::ERR_OK); + auto ret = GetBatteryConfig(sceneName, result, errCode); if (ret != ERR_OK) { - BATTERY_HILOGE(FEATURE_BATT_INFO, "get charge config failed, key:%{public}s", sceneName.c_str()); - return BatteryError::ERR_FAILURE; + BATTERY_HILOGE(FEATURE_BATT_INFO, "GetBatteryConfig error, ret = %{public}d", ret); } - - return BatteryError::ERR_OK; + return BatteryError(errCode); } BatteryError BatteryService::IsBatteryConfigSupported(const std::string& sceneName, bool& result) { - if (!Permission::IsSystem()) { - BATTERY_HILOGI(FEATURE_BATT_INFO, "IsBatteryConfigSupported failed, System permission intercept"); - return BatteryError::ERR_SYSTEM_API_DENIED; - } - - BATTERY_HILOGD(FEATURE_BATT_INFO, "Enter IsBatteryConfigSupported"); - std::shared_lock lock(mutex_); - if (iBatteryInterface_ == nullptr) { - BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr"); - return BatteryError::ERR_FAILURE; - } - - int32_t ret = iBatteryInterface_->IsBatteryConfigSupported(sceneName, result); + int32_t errCode = static_cast(BatteryError::ERR_OK); + auto ret = IsBatteryConfigSupported(sceneName, result, errCode); if (ret != ERR_OK) { - BATTERY_HILOGE(FEATURE_BATT_INFO, "get support charge config failed, key:%{public}s", sceneName.c_str()); - return BatteryError::ERR_FAILURE; + BATTERY_HILOGE(FEATURE_BATT_INFO, "IsBatteryConfigSupported error, ret = %{public}d", ret); } - return BatteryError::ERR_OK; + return BatteryError(errCode); } BatteryChargeState BatteryService::GetChargingStatus() { - if (isMockUnplugged_) { - BATTERY_HILOGD(FEATURE_BATT_INFO, "Return mock charge status"); - return batteryInfo_.GetChargeState(); - } - std::shared_lock lock(mutex_); - V2_0::BatteryChargeState chargeState = V2_0::BatteryChargeState(0); - if (iBatteryInterface_ == nullptr) { - BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr"); - return BatteryChargeState(chargeState); + uint32_t chargeState = static_cast(BatteryChargeState::CHARGE_STATE_BUTT); + auto ret = GetChargingStatus(chargeState); + if (ret != ERR_OK) { + BATTERY_HILOGE(FEATURE_BATT_INFO, "GetChargingStatus error, ret = %{public}d", ret); } - iBatteryInterface_->GetChargeState(chargeState); return BatteryChargeState(chargeState); } BatteryHealthState BatteryService::GetHealthStatus() { - BATTERY_HILOGD(FEATURE_BATT_INFO, "Enter"); - std::shared_lock lock(mutex_); - V2_0::BatteryHealthState healthState = V2_0::BatteryHealthState(0); - if (iBatteryInterface_ == nullptr) { - BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr"); - return BatteryHealthState(healthState); + uint32_t healthState = static_cast(BatteryHealthState::HEALTH_STATE_BUTT); + auto ret = GetChargingStatus(healthState); + if (ret != ERR_OK) { + BATTERY_HILOGE(FEATURE_BATT_INFO, "GetHealthStatus error, ret = %{public}d", ret); } - - iBatteryInterface_->GetHealthState(healthState); return BatteryHealthState(healthState); } BatteryPluggedType BatteryService::GetPluggedType() { - if (isMockUnplugged_) { - BATTERY_HILOGD(FEATURE_BATT_INFO, "Return mock plugged type"); - return batteryInfo_.GetPluggedType(); - } - std::shared_lock lock(mutex_); - V2_0::BatteryPluggedType pluggedType = V2_0::BatteryPluggedType(0); - if (iBatteryInterface_ == nullptr) { - BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr"); - return BatteryPluggedType(pluggedType); + uint32_t pluggedType = static_cast(BatteryPluggedType::PLUGGED_TYPE_BUTT); + auto ret = GetPluggedType(pluggedType); + if (ret != ERR_OK) { + BATTERY_HILOGE(FEATURE_BATT_INFO, "GetPluggedType error, ret = %{public}d", ret); } - iBatteryInterface_->GetPluggedType(pluggedType); return BatteryPluggedType(pluggedType); } int32_t BatteryService::GetVoltage() { - std::shared_lock lock(mutex_); - if (iBatteryInterface_ == nullptr) { - BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr"); - return ERR_NO_INIT; - } int32_t voltage = INVALID_BATT_INT_VALUE; - iBatteryInterface_->GetVoltage(voltage); + auto ret = GetVoltage(voltage); + if (ret != ERR_OK) { + BATTERY_HILOGE(FEATURE_BATT_INFO, "GetVoltage error, ret = %{public}d", ret); + } return voltage; } bool BatteryService::GetPresent() { - std::shared_lock lock(mutex_); - bool present = false; - if (iBatteryInterface_ == nullptr) { - BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr"); - return present; + bool isPresent = false; + auto ret = GetPresent(isPresent); + if (ret != ERR_OK) { + BATTERY_HILOGE(FEATURE_BATT_INFO, "GetPresent error, ret = %{public}d", ret); } - - iBatteryInterface_->GetPresent(present); - return present; + return isPresent; } std::string BatteryService::GetTechnology() { - std::shared_lock lock(mutex_); - if (iBatteryInterface_ == nullptr) { - BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr"); - return ""; - } - std::string technology; - iBatteryInterface_->GetTechnology(technology); + auto ret = GetTechnology(technology); + if (ret != ERR_OK) { + BATTERY_HILOGE(FEATURE_BATT_INFO, "GetTechnology error, ret = %{public}d", ret); + } return technology; } int32_t BatteryService::GetBatteryTemperature() { - std::shared_lock lock(mutex_); - if (iBatteryInterface_ == nullptr) { - BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr"); - return batteryInfo_.GetTemperature(); - } int32_t temperature = INVALID_BATT_INT_VALUE; - iBatteryInterface_->GetTemperature(temperature); + auto ret = GetBatteryTemperature(temperature); + if (ret != ERR_OK) { + BATTERY_HILOGE(FEATURE_BATT_INFO, "GetBatteryTemperature error, ret = %{public}d", ret); + } return temperature; } int32_t BatteryService::GetTotalEnergy() { int32_t totalEnergy = INVALID_BATT_INT_VALUE; - if (!Permission::IsSystem()) { - BATTERY_HILOGD(FEATURE_BATT_INFO, "GetTotalEnergy totalEnergy: %{public}d", totalEnergy); - return totalEnergy; - } - std::shared_lock lock(mutex_); - if (iBatteryInterface_ == nullptr) { - BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr"); - return batteryInfo_.GetTotalEnergy(); + auto ret = GetTotalEnergy(totalEnergy); + if (ret != ERR_OK) { + BATTERY_HILOGE(FEATURE_BATT_INFO, "GetTotalEnergy error, ret = %{public}d", ret); } - iBatteryInterface_->GetTotalEnergy(totalEnergy); return totalEnergy; } int32_t BatteryService::GetCurrentAverage() { - std::shared_lock lock(mutex_); - if (iBatteryInterface_ == nullptr) { - BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr"); - return batteryInfo_.GetCurAverage(); - } int32_t curAverage = INVALID_BATT_INT_VALUE; - iBatteryInterface_->GetCurrentAverage(curAverage); + auto ret = GetCurrentAverage(curAverage); + if (ret != ERR_OK) { + BATTERY_HILOGE(FEATURE_BATT_INFO, "GetCurrentAverage error, ret = %{public}d", ret); + } return curAverage; } int32_t BatteryService::GetNowCurrent() { int32_t nowCurr = INVALID_BATT_INT_VALUE; - std::shared_lock lock(mutex_); - if (iBatteryInterface_ == nullptr) { - BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr"); - return batteryInfo_.GetNowCurrent(); + auto ret = GetNowCurrent(nowCurr); + if (ret != ERR_OK) { + BATTERY_HILOGE(FEATURE_BATT_INFO, "GetNowCurrent error, ret = %{public}d", ret); } - iBatteryInterface_->GetCurrentNow(nowCurr); return nowCurr; } int32_t BatteryService::GetRemainEnergy() { int32_t remainEnergy = INVALID_BATT_INT_VALUE; - if (!Permission::IsSystem()) { - BATTERY_HILOGD(FEATURE_BATT_INFO, "GetRemainEnergy remainEnergy: %{public}d", remainEnergy); - return remainEnergy; - } - std::shared_lock lock(mutex_); - if (iBatteryInterface_ == nullptr) { - BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr"); - return batteryInfo_.GetRemainEnergy(); + auto ret = GetRemainEnergy(remainEnergy); + if (ret != ERR_OK) { + BATTERY_HILOGE(FEATURE_BATT_INFO, "GetRemainEnergy error, ret = %{public}d", ret); } - iBatteryInterface_->GetRemainEnergy(remainEnergy); return remainEnergy; } @@ -847,11 +766,12 @@ void BatteryService::CalculateRemainingChargeTime(int32_t capacity, BatteryCharg int64_t BatteryService::GetRemainingChargeTime() { - if (!Permission::IsSystem()) { - BATTERY_HILOGW(FEATURE_BATT_INFO, "system permission denied."); - return INVALID_REMAINING_CHARGE_TIME_VALUE; + int64_t remainingChargeTime = INVALID_REMAINING_CHARGE_TIME_VALUE; + auto ret = GetRemainingChargeTime(remainingChargeTime); + if (ret != ERR_OK) { + BATTERY_HILOGE(FEATURE_BATT_INFO, "GetRemainingChargeTime error, ret = %{public}d", ret); } - return remainTime_; + return remainingChargeTime; } bool IsCapacityLevelDefined(int32_t capacityThreshold) @@ -996,5 +916,280 @@ 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) +{ + if (isMockCapacity_) { + BATTERY_HILOGD(FEATURE_BATT_INFO, "Return mock battery capacity"); + capacity = batteryInfo_.GetCapacity(); + return ERR_OK; + } + std::shared_lock lock(mutex_); + if (iBatteryInterface_ == nullptr) { + BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr"); + capacity = BATTERY_FULL_CAPACITY; + return ERR_NO_INIT; + } + iBatteryInterface_->GetCapacity(capacity); + return ERR_OK; +} + +int32_t BatteryService::GetChargingStatus(uint32_t& chargingState) +{ + if (isMockUnplugged_) { + BATTERY_HILOGD(FEATURE_BATT_INFO, "Return mock charge status"); + chargingState = static_cast(batteryInfo_.GetChargeState()); + return ERR_OK; + } + std::shared_lock lock(mutex_); + V2_0::BatteryChargeState chargeStateV2 = V2_0::BatteryChargeState(0); + if (iBatteryInterface_ == nullptr) { + BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr"); + chargingState = static_cast(BatteryChargeState(chargeStateV2)); + return ERR_NO_INIT; + } + iBatteryInterface_->GetChargeState(chargeStateV2); + chargingState = static_cast(BatteryChargeState(chargeStateV2)); + return ERR_OK; +} + +int32_t BatteryService::GetHealthStatus(uint32_t& healthStatus) +{ + BATTERY_HILOGD(FEATURE_BATT_INFO, "Enter"); + std::shared_lock lock(mutex_); + V2_0::BatteryHealthState healthStateV2 = V2_0::BatteryHealthState(0); + if (iBatteryInterface_ == nullptr) { + BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr"); + healthStatus = static_cast(BatteryHealthState(healthStateV2)); + return ERR_NO_INIT; + } + + iBatteryInterface_->GetHealthState(healthStateV2); + healthStatus = static_cast(BatteryHealthState(healthStateV2)); + return ERR_OK; +} + +int32_t BatteryService::GetPluggedType(uint32_t& pluggedType) +{ + if (isMockUnplugged_) { + BATTERY_HILOGD(FEATURE_BATT_INFO, "Return mock plugged type"); + pluggedType = static_cast(batteryInfo_.GetPluggedType()); + return ERR_OK; + } + std::shared_lock lock(mutex_); + V2_0::BatteryPluggedType pluggedTypeV2 = V2_0::BatteryPluggedType(0); + if (iBatteryInterface_ == nullptr) { + BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr"); + pluggedType = static_cast(BatteryPluggedType(pluggedTypeV2)); + return ERR_NO_INIT; + } + iBatteryInterface_->GetPluggedType(pluggedTypeV2); + pluggedType = static_cast(BatteryPluggedType(pluggedTypeV2)); + return ERR_OK; +} + +int32_t BatteryService::GetVoltage(int32_t& voltage) +{ + std::shared_lock lock(mutex_); + if (iBatteryInterface_ == nullptr) { + BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr"); + return ERR_NO_INIT; + } + voltage = INVALID_BATT_INT_VALUE; + iBatteryInterface_->GetVoltage(voltage); + return ERR_OK; +} + +int32_t BatteryService::GetPresent(bool& present) +{ + std::shared_lock lock(mutex_); + present = false; + if (iBatteryInterface_ == nullptr) { + BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr"); + return ERR_NO_INIT; + } + + iBatteryInterface_->GetPresent(present); + return ERR_OK; +} + +int32_t BatteryService::GetTechnology(std::string& technology) +{ + std::shared_lock lock(mutex_); + if (iBatteryInterface_ == nullptr) { + BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr"); + return ERR_NO_INIT; + } + + iBatteryInterface_->GetTechnology(technology); + return ERR_OK; +} + +int32_t BatteryService::GetBatteryTemperature(int32_t& temperature) +{ + std::shared_lock lock(mutex_); + if (iBatteryInterface_ == nullptr) { + BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr"); + temperature = batteryInfo_.GetTemperature(); + return ERR_NO_INIT; + } + temperature = INVALID_BATT_INT_VALUE; + iBatteryInterface_->GetTemperature(temperature); + return ERR_OK; +} + +int32_t BatteryService::GetTotalEnergy(int32_t& totalEnergy) +{ + totalEnergy = INVALID_BATT_INT_VALUE; + if (!Permission::IsSystem()) { + BATTERY_HILOGD(FEATURE_BATT_INFO, "GetTotalEnergy totalEnergy: %{public}d", totalEnergy); + return static_cast(BatteryError::ERR_PERMISSION_DENIED); + } + std::shared_lock lock(mutex_); + if (iBatteryInterface_ == nullptr) { + BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr"); + totalEnergy = batteryInfo_.GetTotalEnergy(); + return ERR_NO_INIT; + } + iBatteryInterface_->GetTotalEnergy(totalEnergy); + return ERR_OK; +} + +int32_t BatteryService::GetCurrentAverage(int32_t& currentAverage) +{ + std::shared_lock lock(mutex_); + if (iBatteryInterface_ == nullptr) { + BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr"); + currentAverage = batteryInfo_.GetCurAverage(); + return ERR_NO_INIT; + } + currentAverage = INVALID_BATT_INT_VALUE; + iBatteryInterface_->GetCurrentAverage(currentAverage); + return ERR_OK; +} + +int32_t BatteryService::GetNowCurrent(int32_t& nowCurrent) +{ + nowCurrent = INVALID_BATT_INT_VALUE; + std::shared_lock lock(mutex_); + if (iBatteryInterface_ == nullptr) { + BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr"); + nowCurrent = batteryInfo_.GetNowCurrent(); + return ERR_NO_INIT; + } + iBatteryInterface_->GetCurrentNow(nowCurrent); + return ERR_OK; +} + +int32_t BatteryService::GetRemainEnergy(int32_t& remainEnergy) +{ + remainEnergy = INVALID_BATT_INT_VALUE; + if (!Permission::IsSystem()) { + BATTERY_HILOGD(FEATURE_BATT_INFO, "GetRemainEnergy remainEnergy: %{public}d", remainEnergy); + return static_cast(BatteryError::ERR_PERMISSION_DENIED); + } + std::shared_lock lock(mutex_); + if (iBatteryInterface_ == nullptr) { + BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr"); + remainEnergy = batteryInfo_.GetRemainEnergy(); + return ERR_NO_INIT; + } + iBatteryInterface_->GetRemainEnergy(remainEnergy); + return ERR_OK; +} + +int32_t BatteryService::GetCapacityLevel(int32_t& level) +{ + level = static_cast(GetCapacityLevel()); + return ERR_OK; +} + +int32_t BatteryService::GetRemainingChargeTime(int64_t& time) +{ + if (!Permission::IsSystem()) { + BATTERY_HILOGW(FEATURE_BATT_INFO, "system permission denied."); + time = INVALID_REMAINING_CHARGE_TIME_VALUE; + return static_cast(BatteryError::ERR_PERMISSION_DENIED); + } + time = remainTime_; + return ERR_OK; +} + +int32_t BatteryService::SetBatteryConfig(const std::string& sceneName, const std::string& sceneValue, + int32_t& errorCode) +{ + errorCode = static_cast(BatteryError::ERR_OK); + if (!Permission::IsSystem() || !Permission::IsNativePermissionGranted("ohos.permission.POWER_OPTIMIZATION")) { + BATTERY_HILOGI(FEATURE_BATT_INFO, "SetBatteryConfig failed, System permission intercept"); + errorCode = static_cast(BatteryError::ERR_SYSTEM_API_DENIED); + return errorCode; + } + + BATTERY_HILOGI(FEATURE_BATT_INFO, "Enter SetBatteryConfig sceneName:%{public}s sceneValue:%{public}s", + sceneName.c_str(), sceneValue.c_str()); + std::shared_lock lock(mutex_); + if (iBatteryInterface_ == nullptr) { + BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr"); + errorCode = static_cast(BatteryError::ERR_FAILURE); + return errorCode; + } + int32_t ret = iBatteryInterface_->SetBatteryConfig(sceneName, sceneValue); + if (ret != ERR_OK) { + BATTERY_HILOGE(FEATURE_BATT_INFO, "SetBatteryConfig failed, sceneName:%{public}s", sceneName.c_str()); + errorCode = static_cast(BatteryError::ERR_FAILURE); + } + return errorCode; +} + +int32_t BatteryService::GetBatteryConfig(const std::string& sceneName, std::string& sceneValue, + int32_t& errorCode) +{ + errorCode = static_cast(BatteryError::ERR_OK); + if (!Permission::IsSystem()) { + BATTERY_HILOGI(FEATURE_BATT_INFO, "GetBatteryConfig failed, System permission intercept"); + errorCode = static_cast(BatteryError::ERR_SYSTEM_API_DENIED); + return errorCode; + } + + BATTERY_HILOGD(FEATURE_BATT_INFO, "Enter GetBatteryConfig"); + std::shared_lock lock(mutex_); + if (iBatteryInterface_ == nullptr) { + BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr"); + errorCode = static_cast(BatteryError::ERR_FAILURE); + return errorCode; + } + + int32_t ret = iBatteryInterface_->GetBatteryConfig(sceneName, sceneValue); + if (ret != ERR_OK) { + BATTERY_HILOGE(FEATURE_BATT_INFO, "get charge config failed, key:%{public}s", sceneName.c_str()); + errorCode = static_cast(BatteryError::ERR_FAILURE); + } + return errorCode; +} + +int32_t BatteryService::IsBatteryConfigSupported(const std::string& sceneName, bool& isSupported, int32_t& errorCode) +{ + errorCode = static_cast(BatteryError::ERR_OK); + if (!Permission::IsSystem()) { + BATTERY_HILOGI(FEATURE_BATT_INFO, "IsBatteryConfigSupported failed, System permission intercept"); + errorCode = static_cast(BatteryError::ERR_SYSTEM_API_DENIED); + return errorCode; + } + + BATTERY_HILOGD(FEATURE_BATT_INFO, "Enter IsBatteryConfigSupported"); + std::shared_lock lock(mutex_); + if (iBatteryInterface_ == nullptr) { + BATTERY_HILOGE(FEATURE_BATT_INFO, "iBatteryInterface_ is nullptr"); + errorCode = static_cast(BatteryError::ERR_FAILURE); + return errorCode; + } + + int32_t ret = iBatteryInterface_->IsBatteryConfigSupported(sceneName, isSupported); + if (ret != ERR_OK) { + BATTERY_HILOGE(FEATURE_BATT_INFO, "get support charge config failed, key:%{public}s", sceneName.c_str()); + errorCode = static_cast(BatteryError::ERR_FAILURE); + } + return errorCode; +} } // namespace PowerMgr } // namespace OHOS diff --git a/services/zidl/BUILD.gn b/services/zidl/BUILD.gn index a8f5906..9cf5070 100644 --- a/services/zidl/BUILD.gn +++ b/services/zidl/BUILD.gn @@ -11,17 +11,63 @@ # 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" ] + configs = [ + "${battery_utils}:utils_config", + "${battery_utils}:coverage_flags", + ] + + log_domainid = "0xD002922" + log_tag = "BatterySvc" + part_name = "${batterymgr_native_part_name}" + subsystem_name = "powermgr" +} + +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" ]) + public_configs = [ ":batterysrv_public_config" ] + configs = [ + "${battery_utils}:utils_config", + "${battery_utils}:coverage_flags", + ] + deps = [ ":batterysrv_interface" ] + external_deps = [ + "c_utils:utils", + "hilog:libhilog", + "ipc:ipc_single", + "samgr:samgr_proxy", + ] + part_name = "${batterymgr_native_part_name}" + subsystem_name = "powermgr" +} + +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" ]) + public_configs = [ ":batterysrv_public_config" ] configs = [ "${battery_utils}:utils_config", @@ -29,6 +75,7 @@ ohos_shared_library("batterysrv_stub") { "${battery_utils}:coverage_flags", ] + deps = [ ":batterysrv_interface" ] external_deps = [ "c_utils:utils", "hicollie:libhicollie", diff --git a/services/zidl/IBatterySrv.idl b/services/zidl/IBatterySrv.idl new file mode 100644 index 0000000..63f9a44 --- /dev/null +++ b/services/zidl/IBatterySrv.idl @@ -0,0 +1,34 @@ +/* + * Copyright (c) 2021-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 { + void GetCapacity([out] int capacity); + void GetChargingStatus([out] unsigned int chargingState); + void GetHealthStatus([out] unsigned int healthStatus); + void GetPluggedType([out] unsigned int pluggedType); + void GetVoltage([out] int voltage); + void GetPresent([out] boolean present); + void GetTechnology([out] String technology); + void GetTotalEnergy([out] int totalEnergy); + void GetCurrentAverage([out] int currentAverage); + void GetNowCurrent([out] int nowCurrent); + void GetRemainEnergy([out] int remainEnergy); + void GetBatteryTemperature([out] int temperature); + void GetCapacityLevel([out] int level); + void GetRemainingChargeTime([out] long time); + void SetBatteryConfig([in] String sceneName, [in] String sceneValue, [out] int errorCode); + void GetBatteryConfig([in] String sceneName, [out] String sceneValue, [out] int errorCode); + void IsBatteryConfigSupported([in] String sceneName, [out] boolean isSupported, [out] int errorCode); +} \ 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 06aa440..0000000 --- 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 5e38da1..0000000 --- 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 5bf8e64..0000000 --- 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 e8b7a24..0000000 --- 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 bfc3bcc..f8d561f 100644 --- a/test/benchmarktest/BUILD.gn +++ b/test/benchmarktest/BUILD.gn @@ -32,6 +32,10 @@ ohos_benchmarktest("BatteryBenchmarkTest") { "-fno-strict-aliasing", ] + external_deps = [ + "hilog:libhilog" + ] + subsystem_name = "powermgr" part_name = "battery_manager" } diff --git a/test/unittest/BUILD.gn b/test/unittest/BUILD.gn index 083828c..b0f9314 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", "//third_party/json/single_include", @@ -37,7 +36,6 @@ 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", @@ -311,6 +309,12 @@ ohos_unittest("test_battery_stub") { module_out_path = "${module_output_path}" defines += [ "GTEST" ] + sanitize = { + cfi = true + cfi_cross_dso = true + debug = false + } + sources = [ "${battery_manager_path}/test/utils/test_utils.cpp", "src/battery_srv_stub_test.cpp", @@ -325,6 +329,7 @@ ohos_unittest("test_battery_stub") { deps = [ "${battery_inner_api}:batterysrv_client", "${battery_service_zidl}:batterysrv_stub", + "${battery_service_zidl}:batterysrv_proxy", "${battery_service}:batteryservice", "//third_party/googletest:gtest_main", "//third_party/jsoncpp:jsoncpp", @@ -352,9 +357,12 @@ ohos_unittest("test_battery_stub") { ### test exceptions when Remote() return nullptr ohos_unittest("test_battery_proxy_mock_iremoteobject") { module_out_path = "${module_output_path}" - + sanitize = { + cfi = true + cfi_cross_dso = true + debug = false + } sources = [ - "${battery_service}/zidl/src/battery_srv_proxy.cpp", "mock/source/mock_peer_holder.cpp", "src/battery_srv_proxy_mock_test.cpp", ] @@ -366,7 +374,12 @@ ohos_unittest("test_battery_proxy_mock_iremoteobject") { "${battery_utils}:coverage_flags", ] - deps = [ "//third_party/googletest:gtest_main" ] + public_configs = [ "${battery_service}:batterysrv_public_config" ] + + deps = [ + "//third_party/googletest:gtest_main", + "${battery_service_zidl}:batterysrv_proxy" + ] external_deps = [ "ability_base:base", @@ -388,8 +401,13 @@ ohos_unittest("test_battery_proxy_mock_iremoteobject") { ohos_unittest("test_battery_proxy_mock_messageparcel_write_error") { module_out_path = "${module_output_path}" + sanitize = { + cfi = true + cfi_cross_dso = true + debug = false + } + sources = [ - "${battery_service}/zidl/src/battery_srv_proxy.cpp", "mock/source/mock_message_parcel.cpp", "src/battery_srv_proxy_mock_test.cpp", ] @@ -401,7 +419,11 @@ ohos_unittest("test_battery_proxy_mock_messageparcel_write_error") { "${battery_utils}:coverage_flags", ] - deps = [ "//third_party/googletest:gtest_main" ] + public_configs = [ "${battery_service}:batterysrv_public_config" ] + deps = [ + "//third_party/googletest:gtest_main", + "${battery_service_zidl}:batterysrv_proxy" + ] external_deps = [ "ability_base:base", @@ -424,8 +446,13 @@ ohos_unittest("test_battery_proxy_mock_sendrequest_error") { module_out_path = "${module_output_path}" defines += [ "ENABLE_REMOTE_INTERFACE" ] + sanitize = { + cfi = true + cfi_cross_dso = true + debug = false + } + sources = [ - "${battery_service}/zidl/src/battery_srv_proxy.cpp", "mock/source/mock_remote_object.cpp", "src/battery_srv_proxy_mock_test.cpp", ] @@ -437,7 +464,12 @@ ohos_unittest("test_battery_proxy_mock_sendrequest_error") { "${battery_utils}:coverage_flags", ] - deps = [ "//third_party/googletest:gtest_main" ] + public_configs = [ "${battery_service}:batterysrv_public_config" ] + + deps = [ + "//third_party/googletest:gtest_main", + "${battery_service_zidl}:batterysrv_proxy" + ] external_deps = [ "ability_base:base", @@ -459,8 +491,13 @@ ohos_unittest("test_battery_proxy_mock_sendrequest_error") { ohos_unittest("test_battery_proxy_mock_parcel_read_error") { module_out_path = "${module_output_path}" + sanitize = { + cfi = true + cfi_cross_dso = true + debug = false + } + sources = [ - "${battery_service}/zidl/src/battery_srv_proxy.cpp", "mock/source/mock_parcel.cpp", "src/battery_srv_proxy_mock_test.cpp", ] @@ -472,7 +509,12 @@ ohos_unittest("test_battery_proxy_mock_parcel_read_error") { "${battery_utils}:coverage_flags", ] - deps = [ "//third_party/googletest:gtest_main" ] + public_configs = [ "${battery_service}:batterysrv_public_config" ] + + deps = [ + "//third_party/googletest:gtest_main", + "${battery_service_zidl}:batterysrv_proxy" + ] external_deps = [ "ability_base:base", diff --git a/test/unittest/src/battery_srv_proxy_mock_test.cpp b/test/unittest/src/battery_srv_proxy_mock_test.cpp index 0d8bf54..1930ca1 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 @@ -64,8 +65,10 @@ 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; + auto error = g_proxy->GetCapacity(capacity); EXPECT_TRUE(capacity == INVALID_BATT_INT_VALUE); + EXPECT_TRUE(error != ERR_OK); BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_001 function end!"); } @@ -78,9 +81,12 @@ 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(); - EXPECT_TRUE(chargeState >= BatteryChargeState::CHARGE_STATE_NONE && - chargeState <= BatteryChargeState::CHARGE_STATE_BUTT); // the enum value range of BatteryChargeState + uint32_t chargeState = static_cast(BatteryChargeState::CHARGE_STATE_BUTT); + auto error = g_proxy->GetChargingStatus(chargeState); + EXPECT_TRUE(error != ERR_OK); + // the enum value range of BatteryChargeState + EXPECT_TRUE(BatteryChargeState(chargeState) >= BatteryChargeState::CHARGE_STATE_NONE && + BatteryChargeState(chargeState) <= BatteryChargeState::CHARGE_STATE_BUTT); BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_002 function end!"); } @@ -93,9 +99,12 @@ 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(); - EXPECT_TRUE(healthState >= BatteryHealthState::HEALTH_STATE_UNKNOWN && - healthState <= BatteryHealthState::HEALTH_STATE_BUTT); // the enum value range of BatteryHealthState + uint32_t healthState = static_cast(BatteryHealthState::HEALTH_STATE_BUTT); + auto error = g_proxy->GetHealthStatus(healthState); + EXPECT_TRUE(error != ERR_OK); + // the enum value range of BatteryHealthState + EXPECT_TRUE(BatteryHealthState(healthState) >= BatteryHealthState::HEALTH_STATE_UNKNOWN && + BatteryHealthState(healthState) <= BatteryHealthState::HEALTH_STATE_BUTT); BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_003 function end!"); } @@ -108,9 +117,12 @@ 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(); - EXPECT_TRUE(pluggedType >= BatteryPluggedType::PLUGGED_TYPE_NONE && - pluggedType <= BatteryPluggedType::PLUGGED_TYPE_BUTT); // the enum value range of BatteryPluggedType + uint32_t pluggedType = static_cast(BatteryPluggedType::PLUGGED_TYPE_BUTT); + auto error = g_proxy->GetPluggedType(pluggedType); + EXPECT_TRUE(error != ERR_OK); + // the enum value range of BatteryPluggedType + EXPECT_TRUE(BatteryPluggedType(pluggedType) >= BatteryPluggedType::PLUGGED_TYPE_NONE && + BatteryPluggedType(pluggedType) <= BatteryPluggedType::PLUGGED_TYPE_BUTT); BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_004 function end!"); } @@ -123,21 +135,25 @@ 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; + auto error = g_proxy->GetPresent(isPresent); + EXPECT_TRUE(error != ERR_OK); EXPECT_TRUE(isPresent == INVALID_BATT_BOOL_VALUE); BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_005 function end!"); } /** * @tc.name: BatteryProxyMockTest_006 - * @tc.desc: test BatterySrvProxy::GetTchnology() when an exception is raised + * @tc.desc: test BatterySrvProxy::GetTechnology() when an exception is raised * @tc.type: FUNC * @tc.require: issueI5X13X */ 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; + auto error = g_proxy->GetTechnology(technology); + EXPECT_TRUE(error != ERR_OK); EXPECT_TRUE(technology == INVALID_STRING_VALUE); BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_006 function end!"); } @@ -151,7 +167,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; + auto error = g_proxy->GetTotalEnergy(totalEnergy); + EXPECT_TRUE(error != ERR_OK); EXPECT_TRUE(totalEnergy == INVALID_BATT_INT_VALUE); BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_007 function end!"); } @@ -165,7 +183,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; + auto error = g_proxy->GetCurrentAverage(currentAverage); + EXPECT_TRUE(error != ERR_OK); EXPECT_TRUE(currentAverage == INVALID_BATT_INT_VALUE); BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_008 function end!"); } @@ -179,7 +199,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; + auto error = g_proxy->GetNowCurrent(nowCurrent); + EXPECT_TRUE(error != ERR_OK); EXPECT_TRUE(nowCurrent == INVALID_BATT_INT_VALUE); BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_009 function end!"); } @@ -193,7 +215,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; + auto error = g_proxy->GetRemainEnergy(remainEnergy); + EXPECT_TRUE(error != ERR_OK); EXPECT_TRUE(remainEnergy == INVALID_BATT_INT_VALUE); BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_010 function end!"); } @@ -207,7 +231,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; + auto error = g_proxy->GetBatteryTemperature(temperature); + EXPECT_TRUE(error != ERR_OK); EXPECT_TRUE(temperature == INVALID_BATT_TEMP_VALUE); BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_011 function end!"); } @@ -221,9 +247,12 @@ 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(); - EXPECT_TRUE(batteryLevel >= BatteryCapacityLevel::LEVEL_NONE && - batteryLevel <= BatteryCapacityLevel::LEVEL_RESERVED); // the enum value range of BatteryCapacityLevel + int32_t batteryLevel = static_cast(BatteryCapacityLevel::LEVEL_NONE); + auto error = g_proxy->GetCapacityLevel(batteryLevel); + EXPECT_TRUE(error != ERR_OK); + // the enum value range of BatteryCapacityLevel + EXPECT_TRUE(BatteryCapacityLevel(batteryLevel) >= BatteryCapacityLevel::LEVEL_NONE && + BatteryCapacityLevel(batteryLevel) <= BatteryCapacityLevel::LEVEL_RESERVED); BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_012 function end!"); } @@ -236,7 +265,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; + auto error = g_proxy->GetRemainingChargeTime(remainChargeTime); + EXPECT_TRUE(error != ERR_OK); EXPECT_TRUE(remainChargeTime == INVALID_REMAINING_CHARGE_TIME_VALUE); BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_013 function end!"); } @@ -250,7 +281,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; + auto error = g_proxy->GetVoltage(voltage); + EXPECT_TRUE(error != ERR_OK); EXPECT_TRUE(voltage == INVALID_BATT_INT_VALUE); BATTERY_HILOGI(LABEL_TEST, "BatteryProxyMockTest_014 function end!"); } -- Gitee