1 /*
2 * Copyright (c) 2021-2022 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 "battery_srv_proxy.h"
17
18 #include "errors.h"
19 #include "message_option.h"
20 #include "message_parcel.h"
21 #include "battery_log.h"
22 #include "power_common.h"
23 #include "string_ex.h"
24
25 namespace OHOS {
26 namespace PowerMgr {
GetCapacity()27 int32_t BatterySrvProxy::GetCapacity()
28 {
29 sptr<IRemoteObject> remote = Remote();
30 RETURN_IF_WITH_RET(remote == nullptr, INVALID_BATT_INT_VALUE);
31 MessageParcel data;
32 MessageParcel reply;
33 MessageOption option;
34
35 if (!data.WriteInterfaceToken(BatterySrvProxy::GetDescriptor())) {
36 BATTERY_HILOGW(FEATURE_BATT_INFO, "Write descriptor failed");
37 return INVALID_BATT_INT_VALUE;
38 }
39
40 int ret = remote->SendRequest(static_cast<int>(IBatterySrv::BATT_GET_CAPACITY),
41 data, reply, option);
42 if (ret != ERR_OK) {
43 BATTERY_HILOGW(FEATURE_BATT_INFO, "SendRequest failed, error code: %{public}d", ret);
44 return INVALID_BATT_INT_VALUE;
45 }
46 int32_t capacity = INVALID_BATT_INT_VALUE;
47 READ_PARCEL_WITH_RET(reply, Int32, capacity, INVALID_BATT_INT_VALUE);
48 return capacity;
49 }
50
GetChargingStatus()51 BatteryChargeState BatterySrvProxy::GetChargingStatus()
52 {
53 sptr<IRemoteObject> remote = Remote();
54 RETURN_IF_WITH_RET(remote == nullptr, BatteryChargeState::CHARGE_STATE_BUTT);
55 MessageParcel data;
56 MessageParcel reply;
57 MessageOption option;
58
59 if (!data.WriteInterfaceToken(BatterySrvProxy::GetDescriptor())) {
60 BATTERY_HILOGW(FEATURE_BATT_INFO, "Write descriptor failed");
61 return BatteryChargeState::CHARGE_STATE_BUTT;
62 }
63
64 int ret = remote->SendRequest(static_cast<int>(IBatterySrv::BATT_GET_CHARGING_STATUS),
65 data, reply, option);
66 if (ret != ERR_OK) {
67 BATTERY_HILOGW(FEATURE_BATT_INFO, "SendRequest failed, error code: %{public}d", ret);
68 return BatteryChargeState::CHARGE_STATE_BUTT;
69 }
70 uint32_t chargingState = static_cast<uint32_t>(BatteryChargeState::CHARGE_STATE_BUTT);
71 READ_PARCEL_WITH_RET(reply, Uint32, chargingState, BatteryChargeState::CHARGE_STATE_BUTT);
72 return static_cast<BatteryChargeState>(chargingState);
73 }
74
GetHealthStatus()75 BatteryHealthState BatterySrvProxy::GetHealthStatus()
76 {
77 sptr<IRemoteObject> remote = Remote();
78 RETURN_IF_WITH_RET(remote == nullptr, BatteryHealthState::HEALTH_STATE_BUTT);
79 MessageParcel data;
80 MessageParcel reply;
81 MessageOption option;
82
83 if (!data.WriteInterfaceToken(BatterySrvProxy::GetDescriptor())) {
84 BATTERY_HILOGW(FEATURE_BATT_INFO, "Write descriptor failed");
85 return BatteryHealthState::HEALTH_STATE_BUTT;
86 }
87
88 int ret = remote->SendRequest(static_cast<int>(IBatterySrv::BATT_GET_HEALTH_STATUS),
89 data, reply, option);
90 if (ret != ERR_OK) {
91 BATTERY_HILOGW(FEATURE_BATT_INFO, "SendRequest failed, error code: %{public}d", ret);
92 return BatteryHealthState::HEALTH_STATE_BUTT;
93 }
94 uint32_t healthStatus = static_cast<uint32_t>(BatteryHealthState::HEALTH_STATE_BUTT);
95 READ_PARCEL_WITH_RET(reply, Uint32, healthStatus, BatteryHealthState::HEALTH_STATE_BUTT);
96 return static_cast<BatteryHealthState>(healthStatus);
97 }
98
GetPluggedType()99 BatteryPluggedType BatterySrvProxy::GetPluggedType()
100 {
101 sptr<IRemoteObject> remote = Remote();
102 RETURN_IF_WITH_RET(remote == nullptr, BatteryPluggedType::PLUGGED_TYPE_BUTT);
103 MessageParcel data;
104 MessageParcel reply;
105 MessageOption option;
106
107 if (!data.WriteInterfaceToken(BatterySrvProxy::GetDescriptor())) {
108 BATTERY_HILOGW(FEATURE_BATT_INFO, "Write descriptor failed");
109 return BatteryPluggedType::PLUGGED_TYPE_BUTT;
110 }
111
112 int ret = remote->SendRequest(static_cast<int>(IBatterySrv::BATT_GET_PLUG_TYPE),
113 data, reply, option);
114 if (ret != ERR_OK) {
115 BATTERY_HILOGW(FEATURE_BATT_INFO, "SendRequest failed, error code: %{public}d", ret);
116 return BatteryPluggedType::PLUGGED_TYPE_BUTT;
117 }
118 uint32_t pluggedType = static_cast<uint32_t>(BatteryPluggedType::PLUGGED_TYPE_BUTT);
119 READ_PARCEL_WITH_RET(reply, Uint32, pluggedType, BatteryPluggedType::PLUGGED_TYPE_BUTT);
120 return static_cast<BatteryPluggedType>(pluggedType);
121 }
122
GetVoltage()123 int32_t BatterySrvProxy::GetVoltage()
124 {
125 sptr<IRemoteObject> remote = Remote();
126 RETURN_IF_WITH_RET(remote == nullptr, INVALID_BATT_INT_VALUE);
127 MessageParcel data;
128 MessageParcel reply;
129 MessageOption option;
130
131 if (!data.WriteInterfaceToken(BatterySrvProxy::GetDescriptor())) {
132 BATTERY_HILOGW(FEATURE_BATT_INFO, "Write descriptor failed");
133 return INVALID_BATT_INT_VALUE;
134 }
135
136 int ret = remote->SendRequest(static_cast<int>(IBatterySrv::BATT_GET_VOLTAGE),
137 data, reply, option);
138 if (ret != ERR_OK) {
139 BATTERY_HILOGW(FEATURE_BATT_INFO, "SendRequest failed, error code: %{public}d", ret);
140 return INVALID_BATT_INT_VALUE;
141 }
142 int32_t voltage = INVALID_BATT_INT_VALUE;
143 READ_PARCEL_WITH_RET(reply, Int32, voltage, INVALID_BATT_INT_VALUE);
144 return voltage;
145 }
146
GetPresent()147 bool BatterySrvProxy::GetPresent()
148 {
149 sptr<IRemoteObject> remote = Remote();
150 RETURN_IF_WITH_RET(remote == nullptr, INVALID_BATT_BOOL_VALUE);
151 MessageParcel data;
152 MessageParcel reply;
153 MessageOption option;
154
155 if (!data.WriteInterfaceToken(BatterySrvProxy::GetDescriptor())) {
156 BATTERY_HILOGW(FEATURE_BATT_INFO, "Write descriptor failed");
157 return INVALID_BATT_BOOL_VALUE;
158 }
159
160 int ret = remote->SendRequest(static_cast<int>(IBatterySrv::BATT_GET_PRESENT),
161 data, reply, option);
162 if (ret != ERR_OK) {
163 BATTERY_HILOGW(FEATURE_BATT_INFO, "SendRequest failed, error code: %{public}d", ret);
164 return INVALID_BATT_BOOL_VALUE;
165 }
166 bool present = INVALID_BATT_BOOL_VALUE;
167 READ_PARCEL_WITH_RET(reply, Bool, present, INVALID_BATT_BOOL_VALUE);
168 return present;
169 }
170
GetTechnology()171 std::string BatterySrvProxy::GetTechnology()
172 {
173 sptr<IRemoteObject> remote = Remote();
174 RETURN_IF_WITH_RET(remote == nullptr, INVALID_STRING_VALUE);
175 MessageParcel data;
176 MessageParcel reply;
177 MessageOption option;
178
179 if (!data.WriteInterfaceToken(BatterySrvProxy::GetDescriptor())) {
180 BATTERY_HILOGW(FEATURE_BATT_INFO, "Write descriptor failed");
181 return INVALID_STRING_VALUE;
182 }
183
184 int ret = remote->SendRequest(static_cast<int>(IBatterySrv::BATT_GET_TECHNOLOGY),
185 data, reply, option);
186 if (ret != ERR_OK) {
187 BATTERY_HILOGW(FEATURE_BATT_INFO, "SendRequest failed, error code: %{public}d", ret);
188 return INVALID_STRING_VALUE;
189 }
190 std::u16string technology = Str8ToStr16(INVALID_STRING_VALUE);
191 READ_PARCEL_WITH_RET(reply, String16, technology, INVALID_STRING_VALUE);
192 return Str16ToStr8(technology);
193 }
194
GetBatteryTemperature()195 int32_t BatterySrvProxy::GetBatteryTemperature()
196 {
197 sptr<IRemoteObject> remote = Remote();
198 RETURN_IF_WITH_RET(remote == nullptr, INVALID_BATT_TEMP_VALUE);
199 MessageParcel data;
200 MessageParcel reply;
201 MessageOption option;
202
203 if (!data.WriteInterfaceToken(BatterySrvProxy::GetDescriptor())) {
204 BATTERY_HILOGW(FEATURE_BATT_INFO, "Write descriptor failed");
205 return INVALID_BATT_TEMP_VALUE;
206 }
207
208 int ret = remote->SendRequest(static_cast<int>(IBatterySrv::BATT_GET_TEMPERATURE),
209 data, reply, option);
210 if (ret != ERR_OK) {
211 BATTERY_HILOGW(FEATURE_BATT_INFO, "SendRequest failed, error code: %{public}d", ret);
212 return INVALID_BATT_TEMP_VALUE;
213 }
214 int32_t temperature = INVALID_BATT_TEMP_VALUE;
215 READ_PARCEL_WITH_RET(reply, Int32, temperature, INVALID_BATT_TEMP_VALUE);
216 return temperature;
217 }
218
GetCapacityLevel()219 BatteryCapacityLevel BatterySrvProxy::GetCapacityLevel()
220 {
221 sptr<IRemoteObject> remote = Remote();
222 RETURN_IF_WITH_RET(remote == nullptr, BatteryCapacityLevel::LEVEL_NONE);
223 MessageParcel data;
224 MessageParcel reply;
225 MessageOption option;
226
227 if (!data.WriteInterfaceToken(BatterySrvProxy::GetDescriptor())) {
228 BATTERY_HILOGW(FEATURE_BATT_INFO, "Write descriptor failed");
229 return BatteryCapacityLevel::LEVEL_NONE;
230 }
231
232 int ret = remote->SendRequest(static_cast<int>(IBatterySrv::BATT_GET_BATTERY_LEVEL),
233 data, reply, option);
234 if (ret != ERR_OK) {
235 BATTERY_HILOGW(FEATURE_BATT_INFO, "SendRequest failed, error code: %{public}d", ret);
236 return BatteryCapacityLevel::LEVEL_NONE;
237 }
238 uint32_t level = static_cast<uint32_t>(BatteryCapacityLevel::LEVEL_NONE);
239 READ_PARCEL_WITH_RET(reply, Uint32, level, BatteryCapacityLevel::LEVEL_NONE);
240 return static_cast<BatteryCapacityLevel>(level);
241 }
242
GetRemainingChargeTime()243 int64_t BatterySrvProxy::GetRemainingChargeTime()
244 {
245 sptr<IRemoteObject> remote = Remote();
246 RETURN_IF_WITH_RET(remote == nullptr, INVALID_REMAINING_CHARGE_TIME_VALUE);
247 MessageParcel data;
248 MessageParcel reply;
249 MessageOption option;
250
251 if (!data.WriteInterfaceToken(BatterySrvProxy::GetDescriptor())) {
252 BATTERY_HILOGW(FEATURE_BATT_INFO, "BatterySrvProxy::%{public}s write descriptor failed!", __func__);
253 return INVALID_REMAINING_CHARGE_TIME_VALUE;
254 }
255
256 int ret = remote->SendRequest(static_cast<int>(IBatterySrv::BATT_GET_REMAINING_CHARGE_TIME),
257 data, reply, option);
258 if (ret != ERR_OK) {
259 BATTERY_HILOGW(FEATURE_BATT_INFO, "BatterySrvProxy::%{public}s SendRequest is failed, error code: %d",
260 __func__, ret);
261 return INVALID_REMAINING_CHARGE_TIME_VALUE;
262 }
263 int64_t time = INVALID_REMAINING_CHARGE_TIME_VALUE;
264 READ_PARCEL_WITH_RET(reply, Int64, time, INVALID_REMAINING_CHARGE_TIME_VALUE);
265 return time;
266 }
267
GetTotalEnergy()268 int32_t BatterySrvProxy::GetTotalEnergy()
269 {
270 sptr<IRemoteObject> remote = Remote();
271 RETURN_IF_WITH_RET(remote == nullptr, INVALID_BATT_INT_VALUE);
272 MessageParcel data;
273 MessageParcel reply;
274 MessageOption option;
275
276 if (!data.WriteInterfaceToken(BatterySrvProxy::GetDescriptor())) {
277 BATTERY_HILOGW(FEATURE_BATT_INFO, "Write descriptor failed");
278 return INVALID_BATT_INT_VALUE;
279 }
280
281 int ret = remote->SendRequest(static_cast<int>(IBatterySrv::BATT_GET_BATTERY_TOTAL_ENERGY),
282 data, reply, option);
283 if (ret != ERR_OK) {
284 BATTERY_HILOGW(FEATURE_BATT_INFO, "SendRequest failed, error code: %{public}d", ret);
285 return INVALID_BATT_INT_VALUE;
286 }
287 int32_t totalEnergy = INVALID_BATT_INT_VALUE;
288 READ_PARCEL_WITH_RET(reply, Int32, totalEnergy, INVALID_BATT_INT_VALUE);
289 return totalEnergy;
290 }
291
GetCurrentAverage()292 int32_t BatterySrvProxy::GetCurrentAverage()
293 {
294 sptr<IRemoteObject> remote = Remote();
295 RETURN_IF_WITH_RET(remote == nullptr, INVALID_BATT_INT_VALUE);
296 MessageParcel data;
297 MessageParcel reply;
298 MessageOption option;
299
300 if (!data.WriteInterfaceToken(BatterySrvProxy::GetDescriptor())) {
301 BATTERY_HILOGW(FEATURE_BATT_INFO, "Write descriptor failed");
302 return INVALID_BATT_INT_VALUE;
303 }
304
305 int ret = remote->SendRequest(static_cast<int>(IBatterySrv::BATT_GET_BATTERY_CURRENT_AVERAGE),
306 data, reply, option);
307 if (ret != ERR_OK) {
308 BATTERY_HILOGW(FEATURE_BATT_INFO, "SendRequest failed, error code: %{public}d", ret);
309 return INVALID_BATT_INT_VALUE;
310 }
311 int32_t curAverage = INVALID_BATT_INT_VALUE;
312 READ_PARCEL_WITH_RET(reply, Int32, curAverage, INVALID_BATT_INT_VALUE);
313 return curAverage;
314 }
315
GetNowCurrent()316 int32_t BatterySrvProxy::GetNowCurrent()
317 {
318 sptr<IRemoteObject> remote = Remote();
319 RETURN_IF_WITH_RET(remote == nullptr, INVALID_BATT_INT_VALUE);
320 MessageParcel data;
321 MessageParcel reply;
322 MessageOption option;
323
324 if (!data.WriteInterfaceToken(BatterySrvProxy::GetDescriptor())) {
325 BATTERY_HILOGW(FEATURE_BATT_INFO, "Write descriptor failed");
326 return INVALID_BATT_INT_VALUE;
327 }
328
329 int ret = remote->SendRequest(static_cast<int>(IBatterySrv::BATT_GET_BATTERY_CURRENT_NOW),
330 data, reply, option);
331 if (ret != ERR_OK) {
332 BATTERY_HILOGW(FEATURE_BATT_INFO, "SendRequest failed, error code: %{public}d", ret);
333 return INVALID_BATT_INT_VALUE;
334 }
335 int32_t nowCurr = INVALID_BATT_INT_VALUE;
336 READ_PARCEL_WITH_RET(reply, Int32, nowCurr, INVALID_BATT_INT_VALUE);
337 return nowCurr;
338 }
339
GetRemainEnergy()340 int32_t BatterySrvProxy::GetRemainEnergy()
341 {
342 sptr<IRemoteObject> remote = Remote();
343 RETURN_IF_WITH_RET(remote == nullptr, INVALID_BATT_INT_VALUE);
344 MessageParcel data;
345 MessageParcel reply;
346 MessageOption option;
347
348 if (!data.WriteInterfaceToken(BatterySrvProxy::GetDescriptor())) {
349 BATTERY_HILOGW(FEATURE_BATT_INFO, "Write descriptor failed");
350 return INVALID_BATT_INT_VALUE;
351 }
352
353 int ret = remote->SendRequest(static_cast<int>(IBatterySrv::BATT_GET_BATTERY_REMAIN_ENERGY),
354 data, reply, option);
355 if (ret != ERR_OK) {
356 BATTERY_HILOGW(FEATURE_BATT_INFO, "SendRequest failed, error code: %{public}d", ret);
357 return INVALID_BATT_INT_VALUE;
358 }
359 int32_t remainEnergy = INVALID_BATT_INT_VALUE;
360 READ_PARCEL_WITH_RET(reply, Int32, remainEnergy, INVALID_BATT_INT_VALUE);
361 return remainEnergy;
362 }
363 } // namespace PowerMgr
364 } // namespace OHOS
365