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
26namespace OHOS {
27namespace PowerMgr {
28BatteryStatsInfoList 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
63uint64_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
94uint64_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
125double 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
157void 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
182double 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
214double 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
246double 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
278void 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
301std::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    if (argc > args.size()) {
316        STATS_HILOGE(COMP_FWK, "argc is greater than args size!");
317        return result;
318    }
319
320    data.WriteUint32(argc);
321    for (uint32_t i = 0; i < argc; i++) {
322        data.WriteString(args[i]);
323    }
324    int ret = remote->SendRequest(
325        static_cast<uint32_t>(PowerMgr::BatteryStatsInterfaceCode::BATTERY_STATS_DUMP),
326        data, reply, option);
327    if (ret != ERR_OK) {
328        STATS_HILOGE(COMP_FWK, "SendRequest is failed, error code: %{public}d", ret);
329        return result;
330    }
331    result = reply.ReadString();
332
333    return result;
334}
335
336StatsError BatteryStatsProxy::GetLastError()
337{
338    StatsError tmpError = lastError_;
339    lastError_ = StatsError::ERR_OK;
340    return tmpError;
341}
342} // namespace PowerMgr
343} // namespace OHOS