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