1 /*
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "ohos.batteryInfo.proj.hpp"
17 #include "ohos.batteryInfo.impl.hpp"
18 #include "taihe/runtime.hpp"
19 #include "stdexcept"
20 #include "battery_srv_errors.h"
21 #include "battery_info.h"
22 #include "battery_srv_client.h"
23 #include "battery_log.h"
24
25 #include <cstdint>
26 #include <cstdio>
27 #include <string>
28 #include <map>
29
30 using namespace taihe;
31 using namespace ohos::batteryInfo;
32 using namespace OHOS::PowerMgr;
33
34 namespace {
35 std::map<BatteryError, std::string> g_errorTable = {
36 {BatteryError::ERR_CONNECTION_FAIL, "Connecting to the service failed."},
37 {BatteryError::ERR_PERMISSION_DENIED, "Permission is denied" },
38 {BatteryError::ERR_SYSTEM_API_DENIED, "System permission is denied" },
39 {BatteryError::ERR_PARAM_INVALID, "Invalid input parameter." }
40 };
41 thread_local static BatterySrvClient& g_battClient = BatterySrvClient::GetInstance();
42
SetBatteryConfig(taihe::string_view sceneName,taihe::string_view sceneValue)43 int32_t SetBatteryConfig(taihe::string_view sceneName, taihe::string_view sceneValue)
44 {
45 BatteryError code = g_battClient.SetBatteryConfig(std::string(sceneName), std::string(sceneValue));
46 BATTERY_HILOGI(FEATURE_BATT_INFO, "set charge config, sceneName: %{public}s, value: %{public}s, ret: %{public}d",
47 sceneName.c_str(), sceneValue.c_str(), static_cast<int32_t>(code));
48 if (code != BatteryError::ERR_OK && code != BatteryError::ERR_FAILURE) {
49 taihe::set_business_error(static_cast<int32_t>(code), g_errorTable[code]);
50 return static_cast<int32_t>(code);
51 }
52 return static_cast<int32_t>(code);
53 }
54
GetBatteryConfig(taihe::string_view sceneName)55 taihe::string GetBatteryConfig(taihe::string_view sceneName)
56 {
57 BATTERY_HILOGD(COMP_FWK, "get charge config, sceneName: %{public}s", sceneName.c_str());
58
59 std::string result;
60 BatteryError code = g_battClient.GetBatteryConfig(std::string(sceneName), result);
61 BATTERY_HILOGD(COMP_FWK, "get charge config, sceneValue: %{public}s", result.c_str());
62 if (code != BatteryError::ERR_OK && code != BatteryError::ERR_FAILURE) {
63 taihe::set_business_error(static_cast<int32_t>(code), g_errorTable[code]);
64 return taihe::string(result);
65 }
66 return taihe::string(result);
67 }
68
IsBatteryConfigSupported(taihe::string_view sceneName)69 bool IsBatteryConfigSupported(taihe::string_view sceneName)
70 {
71 BATTERY_HILOGI(COMP_FWK, "get support charge config, featureName: %{public}s", sceneName.c_str());
72
73 bool result = false;
74 BatteryError code = g_battClient.IsBatteryConfigSupported(std::string(sceneName), result);
75
76 BATTERY_HILOGI(COMP_FWK, "get support charge config, sceneValue: %{public}d", static_cast<uint32_t>(result));
77 if (code != BatteryError::ERR_OK && code != BatteryError::ERR_FAILURE) {
78 taihe::set_business_error(static_cast<int32_t>(code), g_errorTable[code]);
79 return result;
80 }
81 return result;
82 }
83
BatterySOC()84 int32_t BatterySOC()
85 {
86 int32_t capacity = g_battClient.GetCapacity();
87 BATTERY_HILOGD(FEATURE_BATT_INFO, "capacity %{public}d", capacity);
88 return capacity;
89 }
90
ChargingStatus()91 ohos::batteryInfo::BatteryChargeState ChargingStatus()
92 {
93 ohos::batteryInfo::BatteryChargeState chargingState =
94 static_cast<ohos::batteryInfo::BatteryChargeState::key_t>(g_battClient.GetChargingStatus());
95 BATTERY_HILOGD(FEATURE_BATT_INFO, "chargingState %{public}d", static_cast<int32_t>(chargingState));
96 return chargingState;
97 }
98
HealthStatus()99 ohos::batteryInfo::BatteryHealthState HealthStatus()
100 {
101 ohos::batteryInfo::BatteryHealthState healthStatus =
102 static_cast<ohos::batteryInfo::BatteryHealthState::key_t>(g_battClient.GetHealthStatus());
103 BATTERY_HILOGD(FEATURE_BATT_INFO, "healthStatus %{public}d", static_cast<int32_t>(healthStatus));
104 return healthStatus;
105 }
106
PluggedType()107 ohos::batteryInfo::BatteryPluggedType PluggedType()
108 {
109 ohos::batteryInfo::BatteryPluggedType pluggedType =
110 static_cast<ohos::batteryInfo::BatteryPluggedType::key_t>(g_battClient.GetPluggedType());
111 BATTERY_HILOGD(FEATURE_BATT_INFO, "pluggedType %{public}d", static_cast<int32_t>(pluggedType));
112 return pluggedType;
113 }
114
Voltage()115 int32_t Voltage()
116 {
117 int32_t voltage = g_battClient.GetVoltage();
118 BATTERY_HILOGD(FEATURE_BATT_INFO, "voltage %{public}d", voltage);
119 return voltage;
120 }
121
Technology()122 taihe::string Technology()
123 {
124 auto technology = g_battClient.GetTechnology();
125 const char* technologyStr = technology.c_str();
126 BATTERY_HILOGD(FEATURE_BATT_INFO, "technology %{public}s", technologyStr);
127 return taihe::string(technology);
128 }
129
BatteryTemperature()130 int32_t BatteryTemperature()
131 {
132 int32_t temperature = g_battClient.GetBatteryTemperature();
133 BATTERY_HILOGD(FEATURE_BATT_INFO, "temperature %{public}d", temperature);
134 return temperature;
135 }
136
IsBatteryPresent()137 bool IsBatteryPresent()
138 {
139 bool present = g_battClient.GetPresent();
140 BATTERY_HILOGD(FEATURE_BATT_INFO, "present %{public}d", present);
141 return present;
142 }
143
GetCapacityLevel()144 ohos::batteryInfo::BatteryCapacityLevel GetCapacityLevel()
145 {
146 ohos::batteryInfo::BatteryCapacityLevel batteryCapacityLevel =
147 static_cast<ohos::batteryInfo::BatteryCapacityLevel::key_t>(g_battClient.GetCapacityLevel());
148 BATTERY_HILOGD(FEATURE_BATT_INFO, "batteryCapacityLevel %{public}d", static_cast<int32_t>(batteryCapacityLevel));
149 return batteryCapacityLevel;
150 }
151
EstimatedRemainingChargeTime()152 int64_t EstimatedRemainingChargeTime()
153 {
154 int64_t time = g_battClient.GetRemainingChargeTime();
155 return time;
156 }
157
TotalEnergy()158 int32_t TotalEnergy()
159 {
160 int32_t totalEnergy = g_battClient.GetTotalEnergy();
161 BATTERY_HILOGD(FEATURE_BATT_INFO, "totalEnergy %{public}d", totalEnergy);
162 return totalEnergy;
163 }
164
NowCurrent()165 int32_t NowCurrent()
166 {
167 int32_t curNow = g_battClient.GetNowCurrent();
168 BATTERY_HILOGD(FEATURE_BATT_INFO, "curNow %{public}d", curNow);
169 return curNow;
170 }
171
RemainingEnergy()172 int32_t RemainingEnergy()
173 {
174 int32_t remainEnergy = g_battClient.GetRemainEnergy();
175 BATTERY_HILOGD(FEATURE_BATT_INFO, "remainEnergy %{public}d", remainEnergy);
176 return remainEnergy;
177 }
178 } // namespace
179
180 // Since these macros are auto-generate, lint will cause false positive
181 // NOLINTBEGIN
182 TH_EXPORT_CPP_API_SetBatteryConfig(SetBatteryConfig);
183 TH_EXPORT_CPP_API_GetBatteryConfig(GetBatteryConfig);
184 TH_EXPORT_CPP_API_IsBatteryConfigSupported(IsBatteryConfigSupported);
185 TH_EXPORT_CPP_API_BatterySOC(BatterySOC);
186 TH_EXPORT_CPP_API_ChargingStatus(ChargingStatus);
187 TH_EXPORT_CPP_API_HealthStatus(HealthStatus);
188 TH_EXPORT_CPP_API_PluggedType(PluggedType);
189 TH_EXPORT_CPP_API_Voltage(Voltage);
190 TH_EXPORT_CPP_API_Technology(Technology);
191 TH_EXPORT_CPP_API_BatteryTemperature(BatteryTemperature);
192 TH_EXPORT_CPP_API_IsBatteryPresent(IsBatteryPresent);
193 TH_EXPORT_CPP_API_GetCapacityLevel(GetCapacityLevel);
194 TH_EXPORT_CPP_API_EstimatedRemainingChargeTime(EstimatedRemainingChargeTime);
195 TH_EXPORT_CPP_API_TotalEnergy(TotalEnergy);
196 TH_EXPORT_CPP_API_NowCurrent(NowCurrent);
197 TH_EXPORT_CPP_API_RemainingEnergy(RemainingEnergy);
198 // NOLINTEND