1 /*
2 * Copyright (c) 2021 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 #include "ipc_types.h"
18 #include "message_parcel.h"
19 #include "power_common.h"
20
21 namespace OHOS {
22 namespace PowerMgr {
GetCapacity()23 int32_t BatterySrvProxy::GetCapacity()
24 {
25 sptr<IRemoteObject> remote = Remote();
26 RETURN_IF_WITH_RET(remote == nullptr, INVALID_BATT_INT_VALUE);
27 MessageParcel data;
28 MessageParcel reply;
29 MessageOption option;
30
31 if (!data.WriteInterfaceToken(BatterySrvProxy::GetDescriptor())) {
32 BATTERY_HILOGW(FEATURE_BATT_INFO, "Write descriptor failed");
33 return INVALID_BATT_INT_VALUE;
34 }
35
36 int ret = remote->SendRequest(static_cast<int>(IBatterySrv::BATT_GET_CAPACITY),
37 data, reply, option);
38 if (ret != ERR_OK) {
39 BATTERY_HILOGW(FEATURE_BATT_INFO, "SendRequest failed, error code: %{public}d", ret);
40 return INVALID_BATT_INT_VALUE;
41 }
42 int32_t capacity = INVALID_BATT_INT_VALUE;
43 READ_PARCEL_WITH_RET(reply, Int32, capacity, INVALID_BATT_INT_VALUE);
44 return capacity;
45 }
46
GetChargingStatus()47 BatteryChargeState BatterySrvProxy::GetChargingStatus()
48 {
49 sptr<IRemoteObject> remote = Remote();
50 RETURN_IF_WITH_RET(remote == nullptr, BatteryChargeState::CHARGE_STATE_BUTT);
51 MessageParcel data;
52 MessageParcel reply;
53 MessageOption option;
54
55 if (!data.WriteInterfaceToken(BatterySrvProxy::GetDescriptor())) {
56 BATTERY_HILOGW(FEATURE_BATT_INFO, "Write descriptor failed");
57 return BatteryChargeState::CHARGE_STATE_BUTT;
58 }
59
60 int ret = remote->SendRequest(static_cast<int>(IBatterySrv::BATT_GET_CHARGING_STATUS),
61 data, reply, option);
62 if (ret != ERR_OK) {
63 BATTERY_HILOGW(FEATURE_BATT_INFO, "SendRequest failed, error code: %{public}d", ret);
64 return BatteryChargeState::CHARGE_STATE_BUTT;
65 }
66 uint32_t chargingState = static_cast<uint32_t>(BatteryChargeState::CHARGE_STATE_BUTT);
67 READ_PARCEL_WITH_RET(reply, Uint32, chargingState, BatteryChargeState::CHARGE_STATE_BUTT);
68 return static_cast<BatteryChargeState>(chargingState);
69 }
70
GetHealthStatus()71 BatteryHealthState BatterySrvProxy::GetHealthStatus()
72 {
73 sptr<IRemoteObject> remote = Remote();
74 RETURN_IF_WITH_RET(remote == nullptr, BatteryHealthState::HEALTH_STATE_BUTT);
75 MessageParcel data;
76 MessageParcel reply;
77 MessageOption option;
78
79 if (!data.WriteInterfaceToken(BatterySrvProxy::GetDescriptor())) {
80 BATTERY_HILOGW(FEATURE_BATT_INFO, "Write descriptor failed");
81 return BatteryHealthState::HEALTH_STATE_BUTT;
82 }
83
84 int ret = remote->SendRequest(static_cast<int>(IBatterySrv::BATT_GET_HEALTH_STATUS),
85 data, reply, option);
86 if (ret != ERR_OK) {
87 BATTERY_HILOGW(FEATURE_BATT_INFO, "SendRequest failed, error code: %{public}d", ret);
88 return BatteryHealthState::HEALTH_STATE_BUTT;
89 }
90 uint32_t healthStatus = static_cast<uint32_t>(BatteryHealthState::HEALTH_STATE_BUTT);
91 READ_PARCEL_WITH_RET(reply, Uint32, healthStatus, BatteryHealthState::HEALTH_STATE_BUTT);
92 return static_cast<BatteryHealthState>(healthStatus);
93 }
94
GetPluggedType()95 BatteryPluggedType BatterySrvProxy::GetPluggedType()
96 {
97 sptr<IRemoteObject> remote = Remote();
98 RETURN_IF_WITH_RET(remote == nullptr, BatteryPluggedType::PLUGGED_TYPE_BUTT);
99 MessageParcel data;
100 MessageParcel reply;
101 MessageOption option;
102
103 if (!data.WriteInterfaceToken(BatterySrvProxy::GetDescriptor())) {
104 BATTERY_HILOGW(FEATURE_BATT_INFO, "Write descriptor failed");
105 return BatteryPluggedType::PLUGGED_TYPE_BUTT;
106 }
107
108 int ret = remote->SendRequest(static_cast<int>(IBatterySrv::BATT_GET_PLUG_TYPE),
109 data, reply, option);
110 if (ret != ERR_OK) {
111 BATTERY_HILOGW(FEATURE_BATT_INFO, "SendRequest failed, error code: %{public}d", ret);
112 return BatteryPluggedType::PLUGGED_TYPE_BUTT;
113 }
114 uint32_t pluggedType = static_cast<uint32_t>(BatteryPluggedType::PLUGGED_TYPE_BUTT);
115 READ_PARCEL_WITH_RET(reply, Uint32, pluggedType, BatteryPluggedType::PLUGGED_TYPE_BUTT);
116 return static_cast<BatteryPluggedType>(pluggedType);
117 }
118
GetVoltage()119 int32_t BatterySrvProxy::GetVoltage()
120 {
121 sptr<IRemoteObject> remote = Remote();
122 RETURN_IF_WITH_RET(remote == nullptr, INVALID_BATT_INT_VALUE);
123 MessageParcel data;
124 MessageParcel reply;
125 MessageOption option;
126
127 if (!data.WriteInterfaceToken(BatterySrvProxy::GetDescriptor())) {
128 BATTERY_HILOGW(FEATURE_BATT_INFO, "Write descriptor failed");
129 return INVALID_BATT_INT_VALUE;
130 }
131
132 int ret = remote->SendRequest(static_cast<int>(IBatterySrv::BATT_GET_VOLTAGE),
133 data, reply, option);
134 if (ret != ERR_OK) {
135 BATTERY_HILOGW(FEATURE_BATT_INFO, "SendRequest failed, error code: %{public}d", ret);
136 return INVALID_BATT_INT_VALUE;
137 }
138 int32_t voltage = INVALID_BATT_INT_VALUE;
139 READ_PARCEL_WITH_RET(reply, Int32, voltage, INVALID_BATT_INT_VALUE);
140 return voltage;
141 }
142
GetPresent()143 bool BatterySrvProxy::GetPresent()
144 {
145 sptr<IRemoteObject> remote = Remote();
146 RETURN_IF_WITH_RET(remote == nullptr, INVALID_BATT_BOOL_VALUE);
147 MessageParcel data;
148 MessageParcel reply;
149 MessageOption option;
150
151 if (!data.WriteInterfaceToken(BatterySrvProxy::GetDescriptor())) {
152 BATTERY_HILOGW(FEATURE_BATT_INFO, "Write descriptor failed");
153 return INVALID_BATT_BOOL_VALUE;
154 }
155
156 int ret = remote->SendRequest(static_cast<int>(IBatterySrv::BATT_GET_PRESENT),
157 data, reply, option);
158 if (ret != ERR_OK) {
159 BATTERY_HILOGW(FEATURE_BATT_INFO, "SendRequest failed, error code: %{public}d", ret);
160 return INVALID_BATT_BOOL_VALUE;
161 }
162 bool present = INVALID_BATT_BOOL_VALUE;
163 READ_PARCEL_WITH_RET(reply, Bool, present, INVALID_BATT_BOOL_VALUE);
164 return present;
165 }
166
GetTechnology()167 std::string BatterySrvProxy::GetTechnology()
168 {
169 std::string technology = INVALID_STRING_VALUE;
170 sptr<IRemoteObject> remote = Remote();
171 RETURN_IF_WITH_RET(remote == nullptr, INVALID_STRING_VALUE);
172 MessageParcel data;
173 MessageParcel reply;
174 MessageOption option;
175
176 if (!data.WriteInterfaceToken(BatterySrvProxy::GetDescriptor())) {
177 BATTERY_HILOGW(FEATURE_BATT_INFO, "Write descriptor failed");
178 return INVALID_STRING_VALUE;
179 }
180
181 int ret = remote->SendRequest(static_cast<int>(IBatterySrv::BATT_GET_TECHNOLOGY),
182 data, reply, option);
183 if (ret != ERR_OK) {
184 BATTERY_HILOGW(FEATURE_BATT_INFO, "SendRequest failed, error code: %{public}d", ret);
185 return INVALID_STRING_VALUE;
186 }
187 READ_PARCEL_WITH_RET(reply, String, technology, INVALID_STRING_VALUE);
188 return technology;
189 }
190
GetBatteryTemperature()191 int32_t BatterySrvProxy::GetBatteryTemperature()
192 {
193 sptr<IRemoteObject> remote = Remote();
194 RETURN_IF_WITH_RET(remote == nullptr, INVALID_BATT_TEMP_VALUE);
195 MessageParcel data;
196 MessageParcel reply;
197 MessageOption option;
198
199 if (!data.WriteInterfaceToken(BatterySrvProxy::GetDescriptor())) {
200 BATTERY_HILOGW(FEATURE_BATT_INFO, "Write descriptor failed");
201 return INVALID_BATT_TEMP_VALUE;
202 }
203
204 int ret = remote->SendRequest(static_cast<int>(IBatterySrv::BATT_GET_TEMPERATURE),
205 data, reply, option);
206 if (ret != ERR_OK) {
207 BATTERY_HILOGW(FEATURE_BATT_INFO, "SendRequest failed, error code: %{public}d", ret);
208 return INVALID_BATT_TEMP_VALUE;
209 }
210 int32_t temperature = INVALID_BATT_TEMP_VALUE;
211 READ_PARCEL_WITH_RET(reply, Int32, temperature, INVALID_BATT_TEMP_VALUE);
212 return temperature;
213 }
214
GetBatteryLevel()215 int32_t BatterySrvProxy::GetBatteryLevel()
216 {
217 sptr<IRemoteObject> remote = Remote();
218 RETURN_IF_WITH_RET(remote == nullptr, INVALID_BATT_LEVEL_VALUE);
219 MessageParcel data;
220 MessageParcel reply;
221 MessageOption option;
222
223 if (!data.WriteInterfaceToken(BatterySrvProxy::GetDescriptor())) {
224 BATTERY_HILOGW(FEATURE_BATT_INFO, "Write descriptor failed");
225 return INVALID_BATT_LEVEL_VALUE;
226 }
227
228 int ret = remote->SendRequest(static_cast<int>(IBatterySrv::BATT_GET_BATTERY_LEVEL),
229 data, reply, option);
230 if (ret != ERR_OK) {
231 BATTERY_HILOGW(FEATURE_BATT_INFO, "SendRequest failed, error code: %{public}d", ret);
232 return INVALID_BATT_LEVEL_VALUE;
233 }
234 int32_t level = INVALID_BATT_LEVEL_VALUE;
235 READ_PARCEL_WITH_RET(reply, Int32, level, INVALID_BATT_LEVEL_VALUE);
236 return level;
237 }
238
GetRemainingChargeTime()239 int64_t BatterySrvProxy::GetRemainingChargeTime()
240 {
241 sptr<IRemoteObject> remote = Remote();
242 RETURN_IF_WITH_RET(remote == nullptr, INVALID_REMAINING_CHARGE_TIME_VALUE);
243 MessageParcel data;
244 MessageParcel reply;
245 MessageOption option;
246
247 if (!data.WriteInterfaceToken(BatterySrvProxy::GetDescriptor())) {
248 BATTERY_HILOGW(FEATURE_BATT_INFO, "BatterySrvProxy::%{public}s write descriptor failed!", __func__);
249 return INVALID_REMAINING_CHARGE_TIME_VALUE;
250 }
251
252 int ret = remote->SendRequest(static_cast<int>(IBatterySrv::BATT_GET_REMAINING_CHARGE_TIME),
253 data, reply, option);
254 if (ret != ERR_OK) {
255 BATTERY_HILOGW(FEATURE_BATT_INFO, "BatterySrvProxy::%{public}s SendRequest is failed, error code: %d",
256 __func__, ret);
257 return INVALID_REMAINING_CHARGE_TIME_VALUE;
258 }
259 int64_t time = INVALID_REMAINING_CHARGE_TIME_VALUE;
260 READ_PARCEL_WITH_RET(reply, Int64, time, INVALID_REMAINING_CHARGE_TIME_VALUE);
261 return time;
262 }
263 } // namespace PowerMgr
264 } // namespace OHOS
265