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