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_stats_proxy.h"
17
18 #include "battery_stats_ipc_interface_code.h"
19 #include <message_parcel.h>
20 #include "errors.h"
21 #include "message_option.h"
22 #include "stats_common.h"
23 #include "stats_log.h"
24 #include "stats_utils.h"
25
26 namespace OHOS {
27 namespace PowerMgr {
GetBatteryStats()28 BatteryStatsInfoList BatteryStatsProxy::GetBatteryStats()
29 {
30 STATS_HILOGD(COMP_FWK, "Enter");
31 BatteryStatsInfoList infoList;
32 sptr<IRemoteObject> remote = Remote();
33 STATS_RETURN_IF_WITH_RET(remote == nullptr, infoList);
34
35 MessageParcel data;
36 MessageParcel reply;
37 MessageOption option;
38
39 if (!data.WriteInterfaceToken(BatteryStatsProxy::GetDescriptor())) {
40 STATS_HILOGE(COMP_FWK, "Write descriptor failed");
41 return infoList;
42 }
43
44 int ret = remote->SendRequest(
45 static_cast<uint32_t>(PowerMgr::BatteryStatsInterfaceCode::BATTERY_STATS_GET),
46 data, reply, option);
47 if (ret != ERR_OK) {
48 STATS_HILOGE(COMP_FWK, "Send request is failed, error code: %{public}d", ret);
49 return infoList;
50 }
51 int32_t size = reply.ReadInt32();
52 for (int32_t i = 0; i < size; ++i) {
53 std::shared_ptr<BatteryStatsInfo> info = std::make_shared<BatteryStatsInfo>();
54 info->ReadFromParcel(reply);
55 infoList.emplace_back(info);
56 }
57 int32_t error;
58 STATS_READ_PARCEL_WITH_RET(COMP_FWK, reply, Int32, error, infoList);
59 lastError_ = static_cast<StatsError>(error);
60 return infoList;
61 }
62
GetTotalTimeSecond(const StatsUtils::StatsType & statsType,const int32_t & uid)63 uint64_t BatteryStatsProxy::GetTotalTimeSecond(const StatsUtils::StatsType& statsType, const int32_t& uid)
64 {
65 STATS_HILOGD(COMP_FWK, "Enter");
66 sptr<IRemoteObject> remote = Remote();
67 STATS_RETURN_IF_WITH_RET(remote == nullptr, StatsUtils::DEFAULT_VALUE);
68
69 MessageParcel data;
70 MessageParcel reply;
71 MessageOption option;
72
73 if (!data.WriteInterfaceToken(BatteryStatsProxy::GetDescriptor())) {
74 STATS_HILOGE(COMP_FWK, "Write descriptor failed");
75 return StatsUtils::DEFAULT_VALUE;
76 }
77
78 uint64_t time = StatsUtils::DEFAULT_VALUE;
79 STATS_WRITE_PARCEL_WITH_RET(COMP_FWK, data, Int32, static_cast<int32_t>(statsType), StatsUtils::DEFAULT_VALUE);
80 STATS_WRITE_PARCEL_WITH_RET(COMP_FWK, data, Int32, uid, StatsUtils::DEFAULT_VALUE);
81
82 int ret = remote->SendRequest(
83 static_cast<uint32_t>(PowerMgr::BatteryStatsInterfaceCode::BATTERY_STATS_GETTIME),
84 data, reply, option);
85 if (ret != ERR_OK) {
86 STATS_HILOGE(COMP_FWK, "Transact is failed, error code: %{public}d", ret);
87 }
88
89 STATS_READ_PARCEL_WITH_RET(COMP_FWK, reply, Uint64, time, StatsUtils::DEFAULT_VALUE);
90 return time;
91 }
92
GetTotalDataBytes(const StatsUtils::StatsType & statsType,const int32_t & uid)93 uint64_t BatteryStatsProxy::GetTotalDataBytes(const StatsUtils::StatsType& statsType, const int32_t& uid)
94 {
95 STATS_HILOGD(COMP_FWK, "Enter");
96 sptr<IRemoteObject> remote = Remote();
97 STATS_RETURN_IF_WITH_RET(remote == nullptr, StatsUtils::DEFAULT_VALUE);
98
99 MessageParcel data;
100 MessageParcel reply;
101 MessageOption option;
102
103 if (!data.WriteInterfaceToken(BatteryStatsProxy::GetDescriptor())) {
104 STATS_HILOGE(COMP_FWK, "Write descriptor failed");
105 return StatsUtils::DEFAULT_VALUE;
106 }
107
108 uint64_t count = StatsUtils::DEFAULT_VALUE;
109 STATS_WRITE_PARCEL_WITH_RET(COMP_FWK, data, Int32, static_cast<int32_t>(statsType), StatsUtils::DEFAULT_VALUE);
110 STATS_WRITE_PARCEL_WITH_RET(COMP_FWK, data, Int32, uid, StatsUtils::DEFAULT_VALUE);
111
112 int ret = remote->SendRequest(
113 static_cast<uint32_t>(PowerMgr::BatteryStatsInterfaceCode::BATTERY_STATS_GETDATA),
114 data, reply, option);
115 if (ret != ERR_OK) {
116 STATS_HILOGE(COMP_FWK, "Transact is failed, error code: %{public}d", ret);
117 }
118
119 STATS_READ_PARCEL_WITH_RET(COMP_FWK, reply, Uint64, count, StatsUtils::DEFAULT_VALUE);
120 return count;
121 }
122
GetAppStatsMah(const int32_t & uid)123 double BatteryStatsProxy::GetAppStatsMah(const int32_t& uid)
124 {
125 STATS_HILOGD(COMP_FWK, "Enter");
126 sptr<IRemoteObject> remote = Remote();
127 STATS_RETURN_IF_WITH_RET(remote == nullptr, StatsUtils::DEFAULT_VALUE);
128
129 MessageParcel data;
130 MessageParcel reply;
131 MessageOption option;
132
133 if (!data.WriteInterfaceToken(BatteryStatsProxy::GetDescriptor())) {
134 STATS_HILOGE(COMP_FWK, "Write descriptor failed");
135 return StatsUtils::DEFAULT_VALUE;
136 }
137
138 data.WriteInt32(uid);
139
140 int ret = remote->SendRequest(
141 static_cast<uint32_t>(PowerMgr::BatteryStatsInterfaceCode::BATTERY_STATS_GETAPPMAH),
142 data, reply, option);
143 if (ret != ERR_OK) {
144 STATS_HILOGE(COMP_FWK, "Transact is failed, error code: %{public}d", ret);
145 }
146
147 double appStatsMah = reply.ReadDouble();
148 STATS_HILOGD(COMP_FWK, "Get stats mah: %{public}lf for uid: %{public}d", appStatsMah, uid);
149 int32_t error;
150 STATS_READ_PARCEL_WITH_RET(COMP_FWK, reply, Int32, error, appStatsMah);
151 lastError_ = static_cast<StatsError>(error);
152 return appStatsMah;
153 }
154
SetOnBattery(bool isOnBattery)155 void BatteryStatsProxy::SetOnBattery(bool isOnBattery)
156 {
157 STATS_HILOGD(COMP_FWK, "Enter");
158 sptr<IRemoteObject> remote = Remote();
159 STATS_RETURN_IF(remote == nullptr);
160
161 MessageParcel data;
162 MessageParcel reply;
163 MessageOption option;
164
165 if (!data.WriteInterfaceToken(BatteryStatsProxy::GetDescriptor())) {
166 STATS_HILOGE(COMP_FWK, "Write descriptor failed");
167 return;
168 }
169
170 data.WriteBool(isOnBattery);
171
172 int ret = remote->SendRequest(
173 static_cast<uint32_t>(PowerMgr::BatteryStatsInterfaceCode::BATTERY_STATS_SETONBATT),
174 data, reply, option);
175 if (ret != ERR_OK) {
176 STATS_HILOGE(COMP_FWK, "Transact is failed, error code: %{public}d", ret);
177 }
178 }
179
GetAppStatsPercent(const int32_t & uid)180 double BatteryStatsProxy::GetAppStatsPercent(const int32_t& uid)
181 {
182 STATS_HILOGD(COMP_FWK, "Enter");
183 sptr<IRemoteObject> remote = Remote();
184 STATS_RETURN_IF_WITH_RET(remote == nullptr, StatsUtils::DEFAULT_VALUE);
185
186 MessageParcel data;
187 MessageParcel reply;
188 MessageOption option;
189
190 if (!data.WriteInterfaceToken(BatteryStatsProxy::GetDescriptor())) {
191 STATS_HILOGE(COMP_FWK, "Write descriptor failed");
192 return StatsUtils::DEFAULT_VALUE;
193 }
194
195 data.WriteInt32(uid);
196
197 int ret = remote->SendRequest(
198 static_cast<uint32_t>(PowerMgr::BatteryStatsInterfaceCode::BATTERY_STATS_GETAPPPER),
199 data, reply, option);
200 if (ret != ERR_OK) {
201 STATS_HILOGE(COMP_FWK, "Transact is failed, error code: %{public}d", ret);
202 }
203
204 double appStatsPercent = reply.ReadDouble();
205 STATS_HILOGD(COMP_FWK, "Get stats percent: %{public}lf for uid: %{public}d", appStatsPercent, uid);
206 int32_t error;
207 STATS_READ_PARCEL_WITH_RET(COMP_FWK, reply, Int32, error, appStatsPercent);
208 lastError_ = static_cast<StatsError>(error);
209 return appStatsPercent;
210 }
211
GetPartStatsMah(const BatteryStatsInfo::ConsumptionType & type)212 double BatteryStatsProxy::GetPartStatsMah(const BatteryStatsInfo::ConsumptionType& type)
213 {
214 STATS_HILOGD(COMP_FWK, "Enter");
215 sptr<IRemoteObject> remote = Remote();
216 STATS_RETURN_IF_WITH_RET(remote == nullptr, StatsUtils::DEFAULT_VALUE);
217
218 MessageParcel data;
219 MessageParcel reply;
220 MessageOption option;
221
222 if (!data.WriteInterfaceToken(BatteryStatsProxy::GetDescriptor())) {
223 STATS_HILOGE(COMP_FWK, "Write descriptor failed");
224 return StatsUtils::DEFAULT_VALUE;
225 }
226
227 data.WriteInt32(type);
228
229 int ret = remote->SendRequest(
230 static_cast<uint32_t>(PowerMgr::BatteryStatsInterfaceCode::BATTERY_STATS_GETPARTMAH),
231 data, reply, option);
232 if (ret != ERR_OK) {
233 STATS_HILOGE(COMP_FWK, "Transact is failed, error code: %{public}d", ret);
234 }
235
236 double partStatsMah = reply.ReadDouble();
237 STATS_HILOGD(COMP_FWK, "Get stats mah: %{public}lf for type: %{public}d", partStatsMah, type);
238 int32_t error;
239 STATS_READ_PARCEL_WITH_RET(COMP_FWK, reply, Int32, error, partStatsMah);
240 lastError_ = static_cast<StatsError>(error);
241 return partStatsMah;
242 }
243
GetPartStatsPercent(const BatteryStatsInfo::ConsumptionType & type)244 double BatteryStatsProxy::GetPartStatsPercent(const BatteryStatsInfo::ConsumptionType& type)
245 {
246 STATS_HILOGD(COMP_FWK, "Enter");
247 sptr<IRemoteObject> remote = Remote();
248 STATS_RETURN_IF_WITH_RET(remote == nullptr, StatsUtils::DEFAULT_VALUE);
249
250 MessageParcel data;
251 MessageParcel reply;
252 MessageOption option;
253
254 if (!data.WriteInterfaceToken(BatteryStatsProxy::GetDescriptor())) {
255 STATS_HILOGE(COMP_FWK, "Write descriptor failed");
256 return StatsUtils::DEFAULT_VALUE;
257 }
258
259 data.WriteInt32(type);
260
261 int ret = remote->SendRequest(
262 static_cast<uint32_t>(PowerMgr::BatteryStatsInterfaceCode::BATTERY_STATS_GETPARTPER),
263 data, reply, option);
264 if (ret != ERR_OK) {
265 STATS_HILOGE(COMP_FWK, "Transact is failed, error code: %{public}d", ret);
266 }
267
268 double partStatsPercent = reply.ReadDouble();
269 STATS_HILOGD(COMP_FWK, "Get stats percent: %{public}lf for type: %{public}d", partStatsPercent, type);
270 int32_t error;
271 STATS_READ_PARCEL_WITH_RET(COMP_FWK, reply, Int32, error, partStatsPercent);
272 lastError_ = static_cast<StatsError>(error);
273 return partStatsPercent;
274 }
275
Reset()276 void BatteryStatsProxy::Reset()
277 {
278 STATS_HILOGD(COMP_FWK, "Enter");
279 sptr<IRemoteObject> remote = Remote();
280 STATS_RETURN_IF(remote == nullptr);
281
282 MessageParcel data;
283 MessageParcel reply;
284 MessageOption option;
285
286 if (!data.WriteInterfaceToken(BatteryStatsProxy::GetDescriptor())) {
287 STATS_HILOGE(COMP_FWK, "Write descriptor failed");
288 return;
289 }
290
291 int ret = remote->SendRequest(
292 static_cast<uint32_t>(PowerMgr::BatteryStatsInterfaceCode::BATTERY_STATS_RESET),
293 data, reply, option);
294 if (ret != ERR_OK) {
295 STATS_HILOGE(COMP_FWK, "Transact is failed, error code: %{public}d", ret);
296 }
297 }
298
ShellDump(const std::vector<std::string> & args,uint32_t argc)299 std::string BatteryStatsProxy::ShellDump(const std::vector<std::string>& args, uint32_t argc)
300 {
301 sptr<IRemoteObject> remote = Remote();
302 std::string result = "remote error";
303 STATS_RETURN_IF_WITH_RET(remote == nullptr, result);
304
305 MessageParcel data;
306 MessageParcel reply;
307 MessageOption option;
308
309 if (!data.WriteInterfaceToken(BatteryStatsProxy::GetDescriptor())) {
310 STATS_HILOGE(COMP_FWK, "Write descriptor failed");
311 return result;
312 }
313
314 data.WriteUint32(argc);
315 for (uint32_t i = 0; i < argc; i++) {
316 data.WriteString(args[i]);
317 }
318 int ret = remote->SendRequest(
319 static_cast<uint32_t>(PowerMgr::BatteryStatsInterfaceCode::BATTERY_STATS_DUMP),
320 data, reply, option);
321 if (ret != ERR_OK) {
322 STATS_HILOGE(COMP_FWK, "SendRequest is failed, error code: %{public}d", ret);
323 return result;
324 }
325 result = reply.ReadString();
326
327 return result;
328 }
329
GetLastError()330 StatsError BatteryStatsProxy::GetLastError()
331 {
332 StatsError tmpError = lastError_;
333 lastError_ = StatsError::ERR_OK;
334 return tmpError;
335 }
336 } // namespace PowerMgr
337 } // namespace OHOS