1 /*
2  * Copyright (c) 2022-2024 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 "powermgr_service_test_proxy.h"
17 
18 #include <message_parcel.h>
19 #include <string_ex.h>
20 
21 #include "errors.h"
22 #include "message_option.h"
23 #include "power_common.h"
24 #include "power_log.h"
25 #include "power_mgr_ipc_interface_code.h"
26 #include "power_mgr_proxy.h"
27 
28 namespace OHOS {
29 namespace PowerMgr {
30 constexpr int32_t MAX_PROXY_RUNNINGLOCK_NUM = 2000;
PowerMgrServiceTestProxy(const sptr<PowerMgrService>& service)31 PowerMgrServiceTestProxy::PowerMgrServiceTestProxy(const sptr<PowerMgrService>& service)
32 {
33     if (service != nullptr) {
34         stub_ = static_cast<PowerMgrStub*>(service);
35     }
36 }
37 
CreateRunningLock(const sptr<IRemoteObject>& remoteObj, const RunningLockInfo& runningLockInfo)38 PowerErrors PowerMgrServiceTestProxy::CreateRunningLock(const sptr<IRemoteObject>& remoteObj,
39     const RunningLockInfo& runningLockInfo)
40 {
41     RETURN_IF_WITH_RET(stub_ == nullptr, PowerErrors::ERR_CONNECTION_FAIL);
42 
43     MessageParcel data;
44     MessageParcel reply;
45     MessageOption option;
46 
47     if (!data.WriteInterfaceToken(PowerMgrProxy::GetDescriptor())) {
48         POWER_HILOGE(FEATURE_RUNNING_LOCK, "Write descriptor failed");
49         return PowerErrors::ERR_CONNECTION_FAIL;
50     }
51 
52     data.WriteRemoteObject(remoteObj.GetRefPtr());
53     data.WriteParcelable(&runningLockInfo);
54 
55     int ret = stub_->OnRemoteRequest(
56         static_cast<int>(PowerMgr::PowerMgrInterfaceCode::CREATE_RUNNINGLOCK),
57         data, reply, option);
58     if (ret != ERR_OK) {
59         POWER_HILOGE(FEATURE_RUNNING_LOCK, "%{public}s: SendRequest failed with ret=%{public}d", __func__, ret);
60         return PowerErrors::ERR_CONNECTION_FAIL;
61     }
62     int32_t error;
63     RETURN_IF_READ_PARCEL_FAILED_WITH_RET(reply, Int32, error, PowerErrors::ERR_OK);
64     return static_cast<PowerErrors>(error);
65 }
66 
ReleaseRunningLock(const sptr<IRemoteObject>& remoteObj, const std::string& name)67 bool PowerMgrServiceTestProxy::ReleaseRunningLock(const sptr<IRemoteObject>& remoteObj, const std::string& name)
68 {
69     RETURN_IF_WITH_RET(stub_ == nullptr, false);
70 
71     MessageParcel data;
72     MessageParcel reply;
73     MessageOption option;
74 
75     if (!data.WriteInterfaceToken(PowerMgrProxy::GetDescriptor())) {
76         POWER_HILOGE(FEATURE_RUNNING_LOCK, "Write descriptor failed");
77         return false;
78     }
79 
80     data.WriteRemoteObject(remoteObj.GetRefPtr());
81     RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, String, name, false);
82 
83     int ret = stub_->OnRemoteRequest(
84         static_cast<int>(PowerMgr::PowerMgrInterfaceCode::RELEASE_RUNNINGLOCK),
85         data, reply, option);
86     if (ret != ERR_OK) {
87         POWER_HILOGE(FEATURE_RUNNING_LOCK, "%{public}s: SendRequest failed with ret=%{public}d", __func__, ret);
88         return false;
89     }
90     return true;
91 }
92 
IsRunningLockTypeSupported(RunningLockType type)93 bool PowerMgrServiceTestProxy::IsRunningLockTypeSupported(RunningLockType type)
94 {
95     RETURN_IF_WITH_RET(stub_ == nullptr, false);
96 
97     bool result = false;
98     MessageParcel data;
99     MessageParcel reply;
100     MessageOption option;
101 
102     if (!data.WriteInterfaceToken(PowerMgrProxy::GetDescriptor())) {
103         POWER_HILOGE(FEATURE_RUNNING_LOCK, "Write descriptor failed");
104         return result;
105     }
106 
107     data.WriteUint32(static_cast<uint32_t>(type));
108 
109     int ret = stub_->OnRemoteRequest(
110         static_cast<int>(PowerMgr::PowerMgrInterfaceCode::IS_RUNNINGLOCK_TYPE_SUPPORTED),
111         data, reply, option);
112     if (ret != ERR_OK) {
113         POWER_HILOGE(FEATURE_RUNNING_LOCK, "%{public}s: SendRequest failed with ret=%{public}d", __func__, ret);
114         return result;
115     }
116 
117     if (!reply.ReadBool(result)) {
118         POWER_HILOGE(FEATURE_RUNNING_LOCK, "ReadBool fail");
119     }
120 
121     return result;
122 }
123 
Lock(const sptr<IRemoteObject>& remoteObj, int32_t timeOutMs)124 bool PowerMgrServiceTestProxy::Lock(const sptr<IRemoteObject>& remoteObj, int32_t timeOutMs)
125 {
126     RETURN_IF_WITH_RET(stub_ == nullptr, false);
127 
128     MessageParcel data;
129     MessageParcel reply;
130     MessageOption option;
131 
132     if (!data.WriteInterfaceToken(PowerMgrProxy::GetDescriptor())) {
133         POWER_HILOGE(FEATURE_RUNNING_LOCK, "Write descriptor failed");
134         return false;
135     }
136 
137     data.WriteRemoteObject(remoteObj.GetRefPtr());
138     data.WriteInt32(timeOutMs);
139 
140     int ret = stub_->OnRemoteRequest(
141         static_cast<int>(PowerMgr::PowerMgrInterfaceCode::RUNNINGLOCK_LOCK),
142         data, reply, option);
143     if (ret != ERR_OK) {
144         POWER_HILOGE(FEATURE_RUNNING_LOCK, "%{public}s: SendRequest failed with ret=%{public}d", __func__, ret);
145         return false;
146     }
147     return true;
148 }
149 
UnLock(const sptr<IRemoteObject>& remoteObj, const std::string& name)150 bool PowerMgrServiceTestProxy::UnLock(const sptr<IRemoteObject>& remoteObj, const std::string& name)
151 {
152     RETURN_IF_WITH_RET(stub_ == nullptr, false);
153 
154     MessageParcel data;
155     MessageParcel reply;
156     MessageOption option;
157 
158     if (!data.WriteInterfaceToken(PowerMgrProxy::GetDescriptor())) {
159         POWER_HILOGE(FEATURE_RUNNING_LOCK, "Write descriptor failed");
160         return false;
161     }
162 
163     data.WriteRemoteObject(remoteObj.GetRefPtr());
164     RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, String, name, false);
165 
166     int ret = stub_->OnRemoteRequest(
167         static_cast<int>(PowerMgr::PowerMgrInterfaceCode::RUNNINGLOCK_UNLOCK),
168         data, reply, option);
169     if (ret != ERR_OK) {
170         POWER_HILOGE(FEATURE_RUNNING_LOCK, "%{public}s: SendRequest failed with ret=%{public}d", __func__, ret);
171         return false;
172     }
173     return true;
174 }
175 
IsUsed(const sptr<IRemoteObject>& remoteObj)176 bool PowerMgrServiceTestProxy::IsUsed(const sptr<IRemoteObject>& remoteObj)
177 {
178     RETURN_IF_WITH_RET(stub_ == nullptr, false);
179 
180     MessageParcel data;
181     MessageParcel reply;
182     MessageOption option;
183 
184     if (!data.WriteInterfaceToken(PowerMgrProxy::GetDescriptor())) {
185         POWER_HILOGE(FEATURE_RUNNING_LOCK, "Write descriptor failed");
186         return false;
187     }
188 
189     data.WriteRemoteObject(remoteObj.GetRefPtr());
190     int ret = stub_->OnRemoteRequest(
191         static_cast<int>(PowerMgr::PowerMgrInterfaceCode::RUNNINGLOCK_ISUSED),
192         data, reply, option);
193     if (ret != ERR_OK) {
194         POWER_HILOGE(FEATURE_RUNNING_LOCK, "%{public}s: SendRequest failed with ret=%{public}d", __func__, ret);
195         return false;
196     }
197     bool used = false;
198     RETURN_IF_READ_PARCEL_FAILED_WITH_RET(reply, Bool, used, false);
199     return used;
200 }
201 
ProxyRunningLock(bool isProxied, pid_t pid, pid_t uid)202 bool PowerMgrServiceTestProxy::ProxyRunningLock(bool isProxied, pid_t pid, pid_t uid)
203 {
204     RETURN_IF_WITH_RET(stub_ == nullptr, false);
205 
206     MessageParcel data;
207     MessageParcel reply;
208     MessageOption option;
209 
210     if (!data.WriteInterfaceToken(PowerMgrProxy::GetDescriptor())) {
211         POWER_HILOGE(FEATURE_RUNNING_LOCK, "Write descriptor failed");
212         return false;
213     }
214 
215     data.WriteBool(isProxied);
216     data.WriteInt32(pid);
217     data.WriteInt32(uid);
218 
219     int ret = stub_->OnRemoteRequest(
220         static_cast<int>(PowerMgr::PowerMgrInterfaceCode::PROXY_RUNNINGLOCK),
221         data, reply, option);
222     if (ret != ERR_OK) {
223         POWER_HILOGE(FEATURE_RUNNING_LOCK, "%{public}s: SendRequest failed with ret=%{public}d", __func__, ret);
224         return false;
225     }
226     bool succ = false;
227     RETURN_IF_READ_PARCEL_FAILED_WITH_RET(reply, Bool, succ, false);
228     return succ;
229 }
230 
ProxyRunningLocks(bool isProxied, const std::vector<std::pair<pid_t, pid_t>>& processInfos)231 bool PowerMgrServiceTestProxy::ProxyRunningLocks(bool isProxied,
232     const std::vector<std::pair<pid_t, pid_t>>& processInfos)
233 {
234     RETURN_IF_WITH_RET(stub_ == nullptr, false);
235 
236     MessageParcel data;
237     MessageParcel reply;
238     MessageOption option;
239 
240     if (!data.WriteInterfaceToken(PowerMgrProxy::GetDescriptor())) {
241         POWER_HILOGE(FEATURE_RUNNING_LOCK, "Write descriptor failed");
242         return false;
243     }
244 
245     int32_t size = processInfos.size();
246     data.WriteBool(isProxied);
247     data.WriteUint32(size);
248     if (size > MAX_PROXY_RUNNINGLOCK_NUM) {
249         POWER_HILOGE(COMP_FWK, "size exceed limit, size=%{public}d", size);
250         return false;
251     }
252     for (int i = 0; i < size; ++i) {
253         data.WriteInt32(processInfos[i].first);
254         data.WriteInt32(processInfos[i].second);
255     }
256 
257     int ret = stub_->OnRemoteRequest(
258         static_cast<int>(PowerMgr::PowerMgrInterfaceCode::PROXY_RUNNINGLOCKS),
259         data, reply, option);
260     if (ret != ERR_OK) {
261         POWER_HILOGE(FEATURE_RUNNING_LOCK, "%{public}s: SendRequest failed with ret=%{public}d", __func__, ret);
262         return false;
263     }
264     bool succ = false;
265     RETURN_IF_READ_PARCEL_FAILED_WITH_RET(reply, Bool, succ, false);
266     return succ;
267 }
268 
ResetRunningLocks()269 bool PowerMgrServiceTestProxy::ResetRunningLocks()
270 {
271     RETURN_IF_WITH_RET(stub_ == nullptr, false);
272 
273     MessageParcel data;
274     MessageParcel reply;
275     MessageOption option;
276 
277     if (!data.WriteInterfaceToken(PowerMgrProxy::GetDescriptor())) {
278         POWER_HILOGE(FEATURE_RUNNING_LOCK, "Write descriptor failed");
279         return false;
280     }
281 
282     int ret = stub_->SendRequest(static_cast<int>(PowerMgr::PowerMgrInterfaceCode::RESET_RUNNINGLOCKS),
283         data, reply, option);
284     if (ret != ERR_OK) {
285         POWER_HILOGE(FEATURE_RUNNING_LOCK, "%{public}s: SendRequest failed with ret=%{public}d", __func__, ret);
286         return false;
287     }
288     bool succ = false;
289     RETURN_IF_READ_PARCEL_FAILED_WITH_RET(reply, Bool, succ, false);
290     return succ;
291 }
292 
RebootDevice(const std::string& reason)293 PowerErrors PowerMgrServiceTestProxy::RebootDevice(const std::string& reason)
294 {
295     RETURN_IF_WITH_RET(stub_ == nullptr, PowerErrors::ERR_CONNECTION_FAIL);
296 
297     MessageParcel data;
298     MessageParcel reply;
299     MessageOption option;
300 
301     if (!data.WriteInterfaceToken(PowerMgrProxy::GetDescriptor())) {
302         POWER_HILOGE(FEATURE_SHUTDOWN, "Write descriptor failed");
303         return PowerErrors::ERR_CONNECTION_FAIL;
304     }
305 
306     data.WriteString16(Str8ToStr16(reason));
307 
308     int ret = stub_->OnRemoteRequest(
309         static_cast<int>(PowerMgr::PowerMgrInterfaceCode::REBOOT_DEVICE), data, reply, option);
310     if (ret != ERR_OK) {
311         POWER_HILOGE(FEATURE_SHUTDOWN, "%{public}s: SendRequest failed with ret=%{public}d", __func__, ret);
312         return PowerErrors::ERR_CONNECTION_FAIL;
313     }
314     int32_t error;
315     RETURN_IF_READ_PARCEL_FAILED_WITH_RET(reply, Int32, error, PowerErrors::ERR_OK);
316     return static_cast<PowerErrors>(error);
317 }
318 
ShutDownDevice(const std::string& reason)319 PowerErrors PowerMgrServiceTestProxy::ShutDownDevice(const std::string& reason)
320 {
321     RETURN_IF_WITH_RET(stub_ == nullptr, PowerErrors::ERR_CONNECTION_FAIL);
322 
323     MessageParcel data;
324     MessageParcel reply;
325     MessageOption option;
326 
327     if (!data.WriteInterfaceToken(PowerMgrProxy::GetDescriptor())) {
328         POWER_HILOGE(FEATURE_SHUTDOWN, "Write descriptor failed");
329         return PowerErrors::ERR_CONNECTION_FAIL;
330     }
331 
332     data.WriteString16(Str8ToStr16(reason));
333 
334     int ret = stub_->OnRemoteRequest(
335         static_cast<int>(PowerMgr::PowerMgrInterfaceCode::SHUTDOWN_DEVICE), data, reply, option);
336     if (ret != ERR_OK) {
337         POWER_HILOGE(FEATURE_SHUTDOWN, "%{public}s: SendRequest failed with ret=%{public}d", __func__, ret);
338         return PowerErrors::ERR_CONNECTION_FAIL;
339     }
340     int32_t error;
341     RETURN_IF_READ_PARCEL_FAILED_WITH_RET(reply, Int32, error, PowerErrors::ERR_OK);
342     return static_cast<PowerErrors>(error);
343 }
344 
SuspendDevice(int64_t callTimeMs, SuspendDeviceType reason, bool suspendImmed)345 PowerErrors PowerMgrServiceTestProxy::SuspendDevice(int64_t callTimeMs, SuspendDeviceType reason, bool suspendImmed)
346 {
347     RETURN_IF_WITH_RET(stub_ == nullptr, PowerErrors::ERR_CONNECTION_FAIL);
348 
349     MessageParcel data;
350     MessageParcel reply;
351     MessageOption option;
352 
353     if (!data.WriteInterfaceToken(PowerMgrProxy::GetDescriptor())) {
354         POWER_HILOGE(FEATURE_SUSPEND, "Write descriptor failed");
355         return PowerErrors::ERR_CONNECTION_FAIL;
356     }
357 
358     data.WriteInt64(callTimeMs);
359     data.WriteUint32(static_cast<uint32_t>(reason));
360     data.WriteBool(suspendImmed);
361 
362     int ret = stub_->OnRemoteRequest(
363         static_cast<int>(PowerMgr::PowerMgrInterfaceCode::SUSPEND_DEVICE), data, reply, option);
364     if (ret != ERR_OK) {
365         POWER_HILOGE(FEATURE_SUSPEND, "%{public}s: SendRequest failed with ret=%{public}d", __func__, ret);
366         return PowerErrors::ERR_CONNECTION_FAIL;
367     }
368     int32_t error;
369     RETURN_IF_READ_PARCEL_FAILED_WITH_RET(reply, Int32, error, PowerErrors::ERR_OK);
370     return static_cast<PowerErrors>(error);
371 }
372 
WakeupDevice(int64_t callTimeMs, WakeupDeviceType reason, const std::string& details)373 PowerErrors PowerMgrServiceTestProxy::WakeupDevice(int64_t callTimeMs, WakeupDeviceType reason,
374     const std::string& details)
375 {
376     RETURN_IF_WITH_RET(stub_ == nullptr, PowerErrors::ERR_CONNECTION_FAIL);
377 
378     MessageParcel data;
379     MessageParcel reply;
380     MessageOption option;
381 
382     if (!data.WriteInterfaceToken(PowerMgrProxy::GetDescriptor())) {
383         POWER_HILOGE(FEATURE_WAKEUP, "Write descriptor failed");
384         return PowerErrors::ERR_CONNECTION_FAIL;
385     }
386 
387     data.WriteInt64(callTimeMs);
388     data.WriteUint32(static_cast<uint32_t>(reason));
389     data.WriteString16(Str8ToStr16(details));
390 
391     int ret = stub_->OnRemoteRequest(
392         static_cast<int>(PowerMgr::PowerMgrInterfaceCode::WAKEUP_DEVICE), data, reply, option);
393     if (ret != ERR_OK) {
394         POWER_HILOGE(FEATURE_WAKEUP, "%{public}s: SendRequest failed with ret=%{public}d", __func__, ret);
395         return PowerErrors::ERR_CONNECTION_FAIL;
396     }
397     int32_t error;
398     RETURN_IF_READ_PARCEL_FAILED_WITH_RET(reply, Int32, error, PowerErrors::ERR_OK);
399     return static_cast<PowerErrors>(error);
400 }
401 
RefreshActivity(int64_t callTimeMs, UserActivityType type, bool needChangeBacklight)402 bool PowerMgrServiceTestProxy::RefreshActivity(int64_t callTimeMs, UserActivityType type, bool needChangeBacklight)
403 {
404     RETURN_IF_WITH_RET(stub_ == nullptr, false);
405 
406     MessageParcel data;
407     MessageParcel reply;
408     MessageOption option;
409 
410     if (!data.WriteInterfaceToken(PowerMgrProxy::GetDescriptor())) {
411         POWER_HILOGE(FEATURE_ACTIVITY, "Write descriptor failed");
412         return false;
413     }
414 
415     data.WriteInt64(callTimeMs);
416     data.WriteUint32(static_cast<uint32_t>(type));
417     data.WriteBool(needChangeBacklight);
418 
419     int ret = stub_->OnRemoteRequest(
420         static_cast<int>(PowerMgr::PowerMgrInterfaceCode::REFRESH_ACTIVITY), data, reply, option);
421     if (ret != ERR_OK) {
422         POWER_HILOGE(FEATURE_ACTIVITY, "%{public}s: SendRequest failed with ret=%{public}d", __func__, ret);
423         return false;
424     }
425     return true;
426 }
427 
OverrideScreenOffTime(int64_t timeout)428 PowerErrors PowerMgrServiceTestProxy::OverrideScreenOffTime(int64_t timeout)
429 {
430     RETURN_IF_WITH_RET(stub_ == nullptr, PowerErrors::ERR_CONNECTION_FAIL);
431 
432     MessageParcel data;
433     MessageParcel reply;
434     MessageOption option;
435 
436     if (!data.WriteInterfaceToken(PowerMgrProxy::GetDescriptor())) {
437         POWER_HILOGE(COMP_SVC, "Write descriptor failed");
438         return PowerErrors::ERR_CONNECTION_FAIL;
439     }
440 
441     data.WriteInt64(timeout);
442 
443     int ret = stub_->OnRemoteRequest(
444         static_cast<int>(PowerMgr::PowerMgrInterfaceCode::OVERRIDE_DISPLAY_OFF_TIME),
445         data, reply, option);
446     if (ret != ERR_OK) {
447         POWER_HILOGE(COMP_SVC, "SendRequest is failed, ret: %{public}d", ret);
448         return PowerErrors::ERR_CONNECTION_FAIL;
449     }
450     int32_t error;
451     RETURN_IF_READ_PARCEL_FAILED_WITH_RET(reply, Int32, error, PowerErrors::ERR_OK);
452     return static_cast<PowerErrors>(error);
453 }
454 
RestoreScreenOffTime()455 PowerErrors PowerMgrServiceTestProxy::RestoreScreenOffTime()
456 {
457     RETURN_IF_WITH_RET(stub_ == nullptr, PowerErrors::ERR_CONNECTION_FAIL);
458 
459     MessageParcel data;
460     MessageParcel reply;
461     MessageOption option;
462 
463     if (!data.WriteInterfaceToken(PowerMgrProxy::GetDescriptor())) {
464         POWER_HILOGE(COMP_FWK, "Write descriptor failed");
465         return PowerErrors::ERR_CONNECTION_FAIL;
466     }
467 
468     int ret = stub_->OnRemoteRequest(
469         static_cast<int>(PowerMgr::PowerMgrInterfaceCode::RESTORE_DISPLAY_OFF_TIME),
470         data, reply, option);
471     if (ret != ERR_OK) {
472         POWER_HILOGE(COMP_FWK, "SendRequest is failed, ret: %{public}d", ret);
473         return PowerErrors::ERR_CONNECTION_FAIL;
474     }
475     int32_t error;
476     RETURN_IF_READ_PARCEL_FAILED_WITH_RET(reply, Int32, error, PowerErrors::ERR_OK);
477     return static_cast<PowerErrors>(error);
478 }
479 
ForceSuspendDevice(int64_t callTimeMs)480 PowerErrors PowerMgrServiceTestProxy::ForceSuspendDevice(int64_t callTimeMs)
481 {
482     RETURN_IF_WITH_RET(stub_ == nullptr, PowerErrors::ERR_CONNECTION_FAIL);
483 
484     MessageParcel data;
485     MessageParcel reply;
486     MessageOption option;
487 
488     if (!data.WriteInterfaceToken(PowerMgrProxy::GetDescriptor())) {
489         POWER_HILOGE(FEATURE_SUSPEND, "Write descriptor failed");
490         return PowerErrors::ERR_CONNECTION_FAIL;
491     }
492 
493     data.WriteInt64(callTimeMs);
494 
495     int ret = stub_->OnRemoteRequest(
496         static_cast<int>(PowerMgr::PowerMgrInterfaceCode::FORCE_DEVICE_SUSPEND),
497         data, reply, option);
498     if (ret != ERR_OK) {
499         POWER_HILOGE(FEATURE_SUSPEND, "SendRequest is failed, ret: %{public}d", ret);
500         return PowerErrors::ERR_CONNECTION_FAIL;
501     }
502     int32_t error;
503     RETURN_IF_READ_PARCEL_FAILED_WITH_RET(reply, Int32, error, PowerErrors::ERR_OK);
504     return static_cast<PowerErrors>(error);
505 }
506 
GetState()507 PowerState PowerMgrServiceTestProxy::GetState()
508 {
509     RETURN_IF_WITH_RET(stub_ == nullptr, PowerState::UNKNOWN);
510 
511     uint32_t result = 0;
512     MessageParcel data;
513     MessageParcel reply;
514     MessageOption option;
515 
516     if (!data.WriteInterfaceToken(PowerMgrProxy::GetDescriptor())) {
517         POWER_HILOGE(FEATURE_POWER_STATE, "Write descriptor failed");
518         return PowerState::UNKNOWN;
519     }
520 
521     int ret = stub_->OnRemoteRequest(
522         static_cast<int>(PowerMgr::PowerMgrInterfaceCode::GET_STATE), data, reply, option);
523     if (ret != ERR_OK) {
524         POWER_HILOGE(FEATURE_POWER_STATE, "%{public}s: SendRequest failed with ret=%{public}d", __func__, ret);
525         return PowerState::UNKNOWN;
526     }
527     if (!reply.ReadUint32(result)) {
528         POWER_HILOGE(FEATURE_POWER_STATE, "ReadUint32 failed");
529         return PowerState::UNKNOWN;
530     }
531 
532     return static_cast<PowerState>(result);
533 }
534 
IsScreenOn(bool needPrintLog)535 bool PowerMgrServiceTestProxy::IsScreenOn(bool needPrintLog)
536 {
537     RETURN_IF_WITH_RET(stub_ == nullptr, false);
538 
539     bool result = false;
540     MessageParcel data;
541     MessageParcel reply;
542     MessageOption option;
543 
544     if (!data.WriteInterfaceToken(PowerMgrProxy::GetDescriptor())) {
545         POWER_HILOGE(COMP_FWK, "Write descriptor failed");
546         return result;
547     }
548     RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Bool, needPrintLog, false);
549 
550     int ret = stub_->OnRemoteRequest(
551         static_cast<int>(PowerMgr::PowerMgrInterfaceCode::IS_SCREEN_ON), data, reply, option);
552     if (ret != ERR_OK) {
553         POWER_HILOGE(COMP_FWK, "%{public}s: SendRequest failed with ret=%{public}d", __func__, ret);
554         return result;
555     }
556     if (!reply.ReadBool(result)) {
557         POWER_HILOGE(COMP_FWK, "ReadBool fail");
558     }
559 
560     return result;
561 }
562 
RegisterPowerStateCallback(const sptr<IPowerStateCallback>& callback, bool isSync)563 bool PowerMgrServiceTestProxy::RegisterPowerStateCallback(const sptr<IPowerStateCallback>& callback, bool isSync)
564 {
565     RETURN_IF_WITH_RET((stub_ == nullptr) || (callback == nullptr), false);
566 
567     MessageParcel data;
568     MessageParcel reply;
569     MessageOption option;
570 
571     if (!data.WriteInterfaceToken(PowerMgrProxy::GetDescriptor())) {
572         POWER_HILOGE(FEATURE_POWER_STATE, "Write descriptor failed");
573         return false;
574     }
575 
576     data.WriteRemoteObject(callback->AsObject());
577     data.WriteBool(isSync);
578 
579     int ret = stub_->OnRemoteRequest(
580         static_cast<int>(PowerMgr::PowerMgrInterfaceCode::REG_POWER_STATE_CALLBACK),
581         data, reply, option);
582     if (ret != ERR_OK) {
583         POWER_HILOGE(FEATURE_POWER_STATE, "%{public}s: SendRequest failed with ret=%{public}d", __func__, ret);
584         return false;
585     }
586     return true;
587 }
588 
UnRegisterPowerStateCallback(const sptr<IPowerStateCallback>& callback)589 bool PowerMgrServiceTestProxy::UnRegisterPowerStateCallback(const sptr<IPowerStateCallback>& callback)
590 {
591     RETURN_IF_WITH_RET((stub_ == nullptr) || (callback == nullptr), false);
592 
593     MessageParcel data;
594     MessageParcel reply;
595     MessageOption option;
596 
597     if (!data.WriteInterfaceToken(PowerMgrProxy::GetDescriptor())) {
598         POWER_HILOGE(FEATURE_POWER_STATE, "Write descriptor failed");
599         return false;
600     }
601 
602     data.WriteRemoteObject(callback->AsObject());
603 
604     int ret = stub_->OnRemoteRequest(
605         static_cast<int>(PowerMgr::PowerMgrInterfaceCode::UNREG_POWER_STATE_CALLBACK),
606         data, reply, option);
607     if (ret != ERR_OK) {
608         POWER_HILOGE(FEATURE_POWER_STATE, "%{public}s: SendRequest failed with ret=%{public}d", __func__, ret);
609         return false;
610     }
611     return true;
612 }
613 
RegisterPowerModeCallback(const sptr<IPowerModeCallback>& callback)614 bool PowerMgrServiceTestProxy::RegisterPowerModeCallback(const sptr<IPowerModeCallback>& callback)
615 {
616     RETURN_IF_WITH_RET((stub_ == nullptr) || (callback == nullptr), false);
617 
618     MessageParcel data;
619     MessageParcel reply;
620     MessageOption option;
621 
622     if (!data.WriteInterfaceToken(PowerMgrProxy::GetDescriptor())) {
623         POWER_HILOGE(FEATURE_POWER_MODE, "Write descriptor failed");
624         return false;
625     }
626 
627     data.WriteRemoteObject(callback->AsObject());
628 
629     int ret = stub_->OnRemoteRequest(
630         static_cast<int>(PowerMgr::PowerMgrInterfaceCode::REG_POWER_MODE_CALLBACK),
631         data, reply, option);
632     if (ret != ERR_OK) {
633         POWER_HILOGE(FEATURE_POWER_MODE, "%{public}s: SendRequest failed with ret=%{public}d", __func__, ret);
634         return false;
635     }
636     return true;
637 }
638 
UnRegisterPowerModeCallback(const sptr<IPowerModeCallback>& callback)639 bool PowerMgrServiceTestProxy::UnRegisterPowerModeCallback(const sptr<IPowerModeCallback>& callback)
640 {
641     RETURN_IF_WITH_RET((stub_ == nullptr) || (callback == nullptr), false);
642 
643     MessageParcel data;
644     MessageParcel reply;
645     MessageOption option;
646 
647     if (!data.WriteInterfaceToken(PowerMgrProxy::GetDescriptor())) {
648         POWER_HILOGE(FEATURE_POWER_MODE, "Write descriptor failed");
649         return false;
650     }
651 
652     data.WriteRemoteObject(callback->AsObject());
653 
654     int ret = stub_->OnRemoteRequest(
655         static_cast<int>(PowerMgr::PowerMgrInterfaceCode::UNREG_POWER_MODE_CALLBACK),
656         data, reply, option);
657     if (ret != ERR_OK) {
658         POWER_HILOGE(FEATURE_POWER_MODE, "%{public}s: SendRequest failed with ret=%{public}d", __func__, ret);
659         return false;
660     }
661     return true;
662 }
663 
RegisterScreenStateCallback(int32_t remainTime, const sptr<IScreenOffPreCallback>& callback)664 bool PowerMgrServiceTestProxy::RegisterScreenStateCallback(int32_t remainTime,
665     const sptr<IScreenOffPreCallback>& callback)
666 {
667     RETURN_IF_WITH_RET((stub_ == nullptr) || (remainTime <= 0) || (callback == nullptr), false);
668 
669     MessageParcel data;
670     MessageParcel reply;
671     MessageOption option;
672 
673     if (!data.WriteInterfaceToken(PowerMgrProxy::GetDescriptor())) {
674         POWER_HILOGE(FEATURE_SCREEN_OFF_PRE, "Write descriptor failed");
675         return false;
676     }
677     data.WriteInt32(remainTime);
678     data.WriteRemoteObject(callback->AsObject());
679 
680     int ret = stub_->OnRemoteRequest(
681         static_cast<int>(PowerMgr::PowerMgrInterfaceCode::REG_SCREEN_OFF_PRE_CALLBACK),
682         data, reply, option);
683     if (ret != ERR_OK) {
684         POWER_HILOGE(FEATURE_SCREEN_OFF_PRE, "%{public}s: SendRequest failed with ret=%{public}d", __func__, ret);
685         return false;
686     }
687     return true;
688 }
689 
UnRegisterScreenStateCallback(const sptr<IScreenOffPreCallback>& callback)690 bool PowerMgrServiceTestProxy::UnRegisterScreenStateCallback(const sptr<IScreenOffPreCallback>& callback)
691 {
692     RETURN_IF_WITH_RET((stub_ == nullptr) || (callback == nullptr), false);
693 
694     MessageParcel data;
695     MessageParcel reply;
696     MessageOption option;
697 
698     if (!data.WriteInterfaceToken(PowerMgrProxy::GetDescriptor())) {
699         POWER_HILOGE(FEATURE_SCREEN_OFF_PRE, "Write descriptor failed");
700         return false;
701     }
702 
703     data.WriteRemoteObject(callback->AsObject());
704 
705     int ret = stub_->OnRemoteRequest(
706         static_cast<int>(PowerMgr::PowerMgrInterfaceCode::UNREG_SCREEN_OFF_PRE_CALLBACK),
707         data, reply, option);
708     if (ret != ERR_OK) {
709         POWER_HILOGE(FEATURE_SCREEN_OFF_PRE, "%{public}s: SendRequest failed with ret=%{public}d", __func__, ret);
710         return false;
711     }
712     return true;
713 }
714 
RegisterRunningLockCallback(const sptr<IPowerRunninglockCallback>& callback)715 bool PowerMgrServiceTestProxy::RegisterRunningLockCallback(const sptr<IPowerRunninglockCallback>& callback)
716 {
717     RETURN_IF_WITH_RET((stub_ == nullptr) || (callback == nullptr), false);
718 
719     MessageParcel data;
720     MessageParcel reply;
721     MessageOption option;
722 
723     if (!data.WriteInterfaceToken(PowerMgrProxy::GetDescriptor())) {
724         POWER_HILOGE(FEATURE_RUNNING_LOCK, "Write descriptor failed");
725         return false;
726     }
727 
728     data.WriteRemoteObject(callback->AsObject());
729 
730     int ret = stub_->OnRemoteRequest(
731         static_cast<int>(PowerMgr::PowerMgrInterfaceCode::REG_RUNNINGLOCK_CALLBACK),
732         data, reply, option);
733     if (ret != ERR_OK) {
734         POWER_HILOGE(FEATURE_RUNNING_LOCK, "%{public}s: SendRequest failed with ret=%{public}d", __func__, ret);
735         return false;
736     }
737     return true;
738 }
739 
UnRegisterRunningLockCallback(const sptr<IPowerRunninglockCallback>& callback)740 bool PowerMgrServiceTestProxy::UnRegisterRunningLockCallback(const sptr<IPowerRunninglockCallback>& callback)
741 {
742     RETURN_IF_WITH_RET((stub_ == nullptr) || (callback == nullptr), false);
743 
744     MessageParcel data;
745     MessageParcel reply;
746     MessageOption option;
747 
748     if (!data.WriteInterfaceToken(PowerMgrProxy::GetDescriptor())) {
749         POWER_HILOGE(FEATURE_RUNNING_LOCK, "Write descriptor failed");
750         return false;
751     }
752 
753     data.WriteRemoteObject(callback->AsObject());
754 
755     int ret = stub_->OnRemoteRequest(
756         static_cast<int>(PowerMgr::PowerMgrInterfaceCode::UNREG_RUNNINGLOCK_CALLBACK),
757         data, reply, option);
758     if (ret != ERR_OK) {
759         POWER_HILOGE(FEATURE_RUNNING_LOCK, "%{public}s: SendRequest failed with ret=%{public}d", __func__, ret);
760         return false;
761     }
762     return true;
763 }
764 
SetDisplaySuspend(bool enable)765 bool PowerMgrServiceTestProxy::SetDisplaySuspend(bool enable)
766 {
767     RETURN_IF_WITH_RET(stub_ == nullptr, false);
768 
769     MessageParcel data;
770     MessageParcel reply;
771     MessageOption option;
772 
773     if (!data.WriteInterfaceToken(PowerMgrProxy::GetDescriptor())) {
774         POWER_HILOGE(FEATURE_SUSPEND, "Write descriptor failed");
775         return false;
776     }
777 
778     data.WriteBool(enable);
779 
780     int ret = stub_->OnRemoteRequest(
781         static_cast<int>(PowerMgr::PowerMgrInterfaceCode::SET_DISPLAY_SUSPEND), data, reply, option);
782     if (ret != ERR_OK) {
783         POWER_HILOGE(FEATURE_SUSPEND, "%{public}s: SendRequest failed with ret=%{public}d", __func__, ret);
784         return false;
785     }
786     return true;
787 }
788 
SetDeviceMode(const PowerMode& mode)789 PowerErrors PowerMgrServiceTestProxy::SetDeviceMode(const PowerMode& mode)
790 {
791     RETURN_IF_WITH_RET(stub_ == nullptr, PowerErrors::ERR_CONNECTION_FAIL);
792 
793     MessageParcel data;
794     MessageParcel reply;
795     MessageOption option;
796 
797     if (!data.WriteInterfaceToken(PowerMgrProxy::GetDescriptor())) {
798         POWER_HILOGE(FEATURE_POWER_MODE, "Write descriptor failed");
799         return PowerErrors::ERR_CONNECTION_FAIL;
800     }
801 
802     data.WriteUint32(static_cast<uint32_t>(mode));
803 
804     int ret = stub_->OnRemoteRequest(
805         static_cast<int>(PowerMgr::PowerMgrInterfaceCode::SETMODE_DEVICE), data, reply, option);
806     if (ret != ERR_OK) {
807         POWER_HILOGE(FEATURE_POWER_MODE, "%{public}s: SendRequest failed with ret=%{public}d", __func__, ret);
808         return PowerErrors::ERR_CONNECTION_FAIL;
809     }
810     int32_t error;
811     RETURN_IF_READ_PARCEL_FAILED_WITH_RET(reply, Int32, error, PowerErrors::ERR_OK);
812     return static_cast<PowerErrors>(error);
813 }
814 
GetDeviceMode()815 PowerMode PowerMgrServiceTestProxy::GetDeviceMode()
816 {
817     RETURN_IF_WITH_RET(stub_ == nullptr, static_cast<PowerMode>(false));
818 
819     MessageParcel data;
820     MessageParcel reply;
821     MessageOption option;
822 
823     if (!data.WriteInterfaceToken(PowerMgrProxy::GetDescriptor())) {
824         POWER_HILOGE(FEATURE_POWER_MODE, "Write descriptor failed");
825         return PowerMode::NORMAL_MODE;
826     }
827 
828     int ret = stub_->OnRemoteRequest(
829         static_cast<int>(PowerMgr::PowerMgrInterfaceCode::GETMODE_DEVICE),
830         data, reply, option);
831     if (ret != ERR_OK) {
832         POWER_HILOGE(FEATURE_POWER_MODE, "%{public}s: SendRequest failed with ret=%{public}d", __func__, ret);
833         return PowerMode::NORMAL_MODE;
834     }
835 
836     uint32_t used = static_cast<uint32_t>(PowerMode::NORMAL_MODE);
837     if (!reply.ReadUint32(used)) {
838         POWER_HILOGE(FEATURE_POWER_MODE, "ReadUint32 fail");
839     }
840     return static_cast<PowerMode>(used);
841 }
842 
ShellDump(const std::vector<std::string>& args, uint32_t argc)843 std::string PowerMgrServiceTestProxy::ShellDump(const std::vector<std::string>& args, uint32_t argc)
844 {
845     std::string result = "remote error";
846     RETURN_IF_WITH_RET(stub_ == nullptr, result);
847 
848     MessageParcel data;
849     MessageParcel reply;
850     MessageOption option;
851 
852     if (!data.WriteInterfaceToken(PowerMgrProxy::GetDescriptor())) {
853         POWER_HILOGE(COMP_FWK, "Write descriptor failed");
854         return result;
855     }
856     if (argc > args.size()) {
857         POWER_HILOGE(COMP_FWK, "argc is greater than args size!");
858         return result;
859     }
860 
861     data.WriteUint32(argc);
862     for (uint32_t i = 0; i < argc; i++) {
863         data.WriteString(args[i]);
864     }
865     int ret = stub_->OnRemoteRequest(
866         static_cast<int>(PowerMgr::PowerMgrInterfaceCode::SHELL_DUMP),
867         data, reply, option);
868     if (ret != ERR_OK) {
869         POWER_HILOGE(COMP_FWK, "%{public}s: SendRequest failed with ret=%{public}d", __func__, ret);
870         return result;
871     }
872     result = reply.ReadString();
873 
874     return result;
875 }
876 
IsStandby(bool& isStandby)877 PowerErrors PowerMgrServiceTestProxy::IsStandby(bool& isStandby)
878 {
879     RETURN_IF_WITH_RET(stub_ == nullptr, PowerErrors::ERR_CONNECTION_FAIL);
880 
881     MessageParcel data;
882     MessageParcel reply;
883     MessageOption option;
884 
885     if (!data.WriteInterfaceToken(PowerMgrProxy::GetDescriptor())) {
886         POWER_HILOGE(COMP_FWK, "Write descriptor failed");
887         return PowerErrors::ERR_CONNECTION_FAIL;
888     }
889 
890     int32_t ret = stub_->SendRequest(
891         static_cast<int>(PowerMgr::PowerMgrInterfaceCode::IS_STANDBY), data, reply, option);
892     if (ret != ERR_OK) {
893         POWER_HILOGE(COMP_FWK, "%{public}s: SendRequest failed with ret=%{public}d", __func__, ret);
894         return PowerErrors::ERR_CONNECTION_FAIL;
895     }
896 
897     int32_t error;
898 
899     RETURN_IF_READ_PARCEL_FAILED_WITH_RET(reply, Int32, error, PowerErrors::ERR_CONNECTION_FAIL);
900     RETURN_IF_READ_PARCEL_FAILED_WITH_RET(reply, Bool, isStandby, PowerErrors::ERR_CONNECTION_FAIL);
901 
902     return static_cast<PowerErrors>(error);
903 }
904 } // namespace PowerMgr
905 } // namespace OHOS
906