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