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 "devicestatus_srv_proxy.h"
17 
18 #include "hitrace_meter.h"
19 #include "iremote_object.h"
20 #include <message_option.h>
21 #include <message_parcel.h>
22 
23 #include "devicestatus_common.h"
24 #include "devicestatus_define.h"
25 #include "drag_data_packer.h"
26 #include "preview_style_packer.h"
27 #include "stationary_callback.h"
28 #include "stationary_data.h"
29 #include "utility.h"
30 
31 #undef LOG_TAG
32 #define LOG_TAG "DeviceStatusSrvProxy"
33 
34 namespace OHOS {
35 namespace Msdp {
36 namespace DeviceStatus {
37 
Subscribe(Type type,ActivityEvent event,ReportLatencyNs latency,sptr<IRemoteDevStaCallback> callback)38 void DeviceStatusSrvProxy::Subscribe(Type type, ActivityEvent event, ReportLatencyNs latency,
39     sptr<IRemoteDevStaCallback> callback)
40 {
41     CALL_DEBUG_ENTER;
42     FI_HILOGI("Enter event:%{public}d, latency:%{public}d", event, latency);
43     sptr<IRemoteObject> remote = Remote();
44     DEV_RET_IF_NULL((remote == nullptr) || (callback == nullptr));
45 
46     MessageParcel data;
47     if (!data.WriteInterfaceToken(DeviceStatusSrvProxy::GetDescriptor())) {
48         FI_HILOGE("Write descriptor failed");
49         return;
50     }
51 
52     WRITEINT32(data, type);
53     WRITEINT32(data, event);
54     WRITEINT32(data, latency);
55     WRITEREMOTEOBJECT(data, callback->AsObject());
56 
57     MessageParcel reply;
58     MessageOption option;
59     int32_t ret = remote->SendRequest(static_cast<uint32_t>(DeviceInterfaceCode::DEVICESTATUS_SUBSCRIBE),
60         data, reply, option);
61     if (ret != RET_OK) {
62         FI_HILOGE("SendRequest is failed, errCode:%{public}d", ret);
63         return;
64     }
65 }
66 
Unsubscribe(Type type,ActivityEvent event,sptr<IRemoteDevStaCallback> callback)67 void DeviceStatusSrvProxy::Unsubscribe(Type type, ActivityEvent event, sptr<IRemoteDevStaCallback> callback)
68 {
69     CALL_DEBUG_ENTER;
70     FI_HILOGD("Enter, event:%{public}d", event);
71     StartTrace(HITRACE_TAG_MSDP, "clientUnSubscribeStart");
72     sptr<IRemoteObject> remote = Remote();
73     DEV_RET_IF_NULL((remote == nullptr) || (callback == nullptr));
74 
75     MessageParcel data;
76     if (!data.WriteInterfaceToken(DeviceStatusSrvProxy::GetDescriptor())) {
77         FI_HILOGE("Write descriptor failed");
78         return;
79     }
80     WRITEINT32(data, type);
81     WRITEINT32(data, event);
82     WRITEREMOTEOBJECT(data, callback->AsObject());
83 
84     MessageParcel reply;
85     MessageOption option;
86     int32_t ret = remote->SendRequest(static_cast<uint32_t>(DeviceInterfaceCode::DEVICESTATUS_UNSUBSCRIBE),
87         data, reply, option);
88     if (ret != RET_OK) {
89         FI_HILOGE("SendRequest is failed, errCode:%{public}d", ret);
90         return;
91     }
92 }
93 
GetCache(const Type & type)94 Data DeviceStatusSrvProxy::GetCache(const Type &type)
95 {
96     CALL_DEBUG_ENTER;
97     Data devicestatusData;
98     devicestatusData.type = Type::TYPE_INVALID;
99     devicestatusData.value = OnChangedValue::VALUE_INVALID;
100 
101     sptr<IRemoteObject> remote = Remote();
102     DEV_RET_IF_NULL_WITH_RET((remote == nullptr), devicestatusData);
103 
104     MessageParcel data;
105     if (!data.WriteInterfaceToken(DeviceStatusSrvProxy::GetDescriptor())) {
106         FI_HILOGE("Write descriptor failed");
107         return devicestatusData;
108     }
109     WRITEINT32(data, type, devicestatusData);
110 
111     MessageParcel reply;
112     MessageOption option;
113     int32_t ret = remote->SendRequest(static_cast<uint32_t>(DeviceInterfaceCode::DEVICESTATUS_GETCACHE),
114         data, reply, option);
115     if (ret != RET_OK) {
116         FI_HILOGE("SendRequest is failed, errCode:%{public}d", ret);
117         return devicestatusData;
118     }
119 
120     int32_t devicestatusType = -1;
121     int32_t devicestatusValue = -1;
122     READINT32(reply, devicestatusType, devicestatusData);
123     READINT32(reply, devicestatusValue, devicestatusData);
124     devicestatusData.type = static_cast<Type>(devicestatusType);
125     devicestatusData.value = static_cast<OnChangedValue>(devicestatusValue);
126     FI_HILOGD("type:%{public}d, value:%{public}d", devicestatusData.type, devicestatusData.value);
127     return devicestatusData;
128 }
129 
RegisterCoordinationListener(bool isCompatible)130 int32_t DeviceStatusSrvProxy::RegisterCoordinationListener(bool isCompatible)
131 {
132     CALL_DEBUG_ENTER;
133     MessageParcel data;
134     if (!data.WriteInterfaceToken(DeviceStatusSrvProxy::GetDescriptor())) {
135         FI_HILOGE("Failed to write descriptor");
136         return ERR_INVALID_VALUE;
137     }
138     sptr<IRemoteObject> remote = Remote();
139     CHKPR(remote, RET_ERR);
140     MessageParcel reply;
141     MessageOption option;
142     int32_t ret = -1;
143     if (isCompatible) {
144         ret = remote->SendRequest(static_cast<uint32_t>(DeviceInterfaceCode::REGISTER_COOPERATE_MONITOR),
145             data, reply, option);
146     } else {
147         ret = remote->SendRequest(static_cast<uint32_t>(DeviceInterfaceCode::REGISTER_COORDINATION_MONITOR),
148             data, reply, option);
149     }
150     if (ret != RET_OK) {
151         FI_HILOGE("Send request failed, ret:%{public}d", ret);
152     }
153     return ret;
154 }
155 
UnregisterCoordinationListener(bool isCompatible)156 int32_t DeviceStatusSrvProxy::UnregisterCoordinationListener(bool isCompatible)
157 {
158     CALL_DEBUG_ENTER;
159     MessageParcel data;
160     if (!data.WriteInterfaceToken(DeviceStatusSrvProxy::GetDescriptor())) {
161         FI_HILOGE("Failed to write descriptor");
162         return ERR_INVALID_VALUE;
163     }
164     sptr<IRemoteObject> remote = Remote();
165     CHKPR(remote, RET_ERR);
166     MessageOption option;
167     MessageParcel reply;
168     int32_t ret = -1;
169     if (isCompatible) {
170         ret = remote->SendRequest(static_cast<uint32_t>(DeviceInterfaceCode::UNREGISTER_COOPERATE_MONITOR),
171             data, reply, option);
172     } else {
173         ret = remote->SendRequest(static_cast<uint32_t>(DeviceInterfaceCode::UNREGISTER_COORDINATION_MONITOR),
174             data, reply, option);
175     }
176     if (ret != RET_OK) {
177         FI_HILOGE("Send request failed, ret:%{public}d", ret);
178     }
179     return ret;
180 }
181 
PrepareCoordination(int32_t userData,bool isCompatible)182 int32_t DeviceStatusSrvProxy::PrepareCoordination(int32_t userData, bool isCompatible)
183 {
184     CALL_DEBUG_ENTER;
185     MessageParcel data;
186     if (!data.WriteInterfaceToken(DeviceStatusSrvProxy::GetDescriptor())) {
187         FI_HILOGE("Failed to write descriptor");
188         return ERR_INVALID_VALUE;
189     }
190     WRITEINT32(data, userData, ERR_INVALID_VALUE);
191     sptr<IRemoteObject> remote = Remote();
192     CHKPR(remote, RET_ERR);
193     MessageOption option;
194     MessageParcel reply;
195     int32_t ret = -1;
196     if (isCompatible) {
197         ret = remote->SendRequest(static_cast<uint32_t>(DeviceInterfaceCode::PREPARE_COOPERATE),
198             data, reply, option);
199     } else {
200         ret = remote->SendRequest(static_cast<uint32_t>(DeviceInterfaceCode::PREPARE_COORDINATION),
201             data, reply, option);
202     }
203     if (ret != RET_OK) {
204         FI_HILOGE("Send request failed, ret:%{public}d", ret);
205     }
206     return ret;
207 }
208 
UnprepareCoordination(int32_t userData,bool isCompatible)209 int32_t DeviceStatusSrvProxy::UnprepareCoordination(int32_t userData, bool isCompatible)
210 {
211     CALL_DEBUG_ENTER;
212     MessageParcel data;
213     if (!data.WriteInterfaceToken(DeviceStatusSrvProxy::GetDescriptor())) {
214         FI_HILOGE("Failed to write descriptor");
215         return ERR_INVALID_VALUE;
216     }
217     WRITEINT32(data, userData, ERR_INVALID_VALUE);
218     sptr<IRemoteObject> remote = Remote();
219     CHKPR(remote, RET_ERR);
220     MessageParcel reply;
221     MessageOption option;
222     int32_t ret = -1;
223     if (isCompatible) {
224         ret = remote->SendRequest(static_cast<uint32_t>(DeviceInterfaceCode::UNPREPARE_COOPERATE),
225             data, reply, option);
226     } else {
227         ret = remote->SendRequest(static_cast<uint32_t>(DeviceInterfaceCode::UNPREPARE_COORDINATION),
228             data, reply, option);
229     }
230     if (ret != RET_OK) {
231         FI_HILOGE("Send request failed, ret:%{public}d", ret);
232     }
233     return ret;
234 }
235 
ActivateCoordination(int32_t userData,const std::string & remoteNetworkId,int32_t startDeviceId,bool isCompatible)236 int32_t DeviceStatusSrvProxy::ActivateCoordination(int32_t userData, const std::string &remoteNetworkId,
237     int32_t startDeviceId, bool isCompatible)
238 {
239     CALL_DEBUG_ENTER;
240     MessageParcel data;
241     if (!data.WriteInterfaceToken(DeviceStatusSrvProxy::GetDescriptor())) {
242         FI_HILOGE("Failed to write descriptor");
243         return ERR_INVALID_VALUE;
244     }
245     WRITEINT32(data, userData, ERR_INVALID_VALUE);
246     WRITESTRING(data, remoteNetworkId, ERR_INVALID_VALUE);
247     WRITEINT32(data, startDeviceId, ERR_INVALID_VALUE);
248     sptr<IRemoteObject> remote = Remote();
249     CHKPR(remote, RET_ERR);
250     MessageParcel reply;
251     MessageOption option;
252     int32_t ret = -1;
253     if (isCompatible) {
254         ret = remote->SendRequest(static_cast<uint32_t>(DeviceInterfaceCode::START_COOPERATE),
255             data, reply, option);
256     } else {
257         ret = remote->SendRequest(static_cast<uint32_t>(DeviceInterfaceCode::START_COORDINATION),
258             data, reply, option);
259     }
260     if (ret != RET_OK) {
261         FI_HILOGE("Send request failed, ret:%{public}d", ret);
262     }
263     return ret;
264 }
265 
DeactivateCoordination(int32_t userData,bool isUnchained,bool isCompatible)266 int32_t DeviceStatusSrvProxy::DeactivateCoordination(int32_t userData, bool isUnchained, bool isCompatible)
267 {
268     CALL_DEBUG_ENTER;
269     MessageParcel data;
270     if (!data.WriteInterfaceToken(DeviceStatusSrvProxy::GetDescriptor())) {
271         FI_HILOGE("Failed to write descriptor");
272         return ERR_INVALID_VALUE;
273     }
274     WRITEINT32(data, userData, ERR_INVALID_VALUE);
275     WRITEBOOL(data, isUnchained, ERR_INVALID_VALUE);
276     sptr<IRemoteObject> remote = Remote();
277     CHKPR(remote, RET_ERR);
278     MessageParcel reply;
279     MessageOption option;
280     int32_t ret = -1;
281     if (isCompatible) {
282         ret = remote->SendRequest(static_cast<uint32_t>(DeviceInterfaceCode::STOP_COOPERATE),
283             data, reply, option);
284     } else {
285         ret = remote->SendRequest(static_cast<uint32_t>(DeviceInterfaceCode::STOP_COORDINATION),
286             data, reply, option);
287     }
288     if (ret != RET_OK) {
289         FI_HILOGE("Send request failed, ret:%{public}d", ret);
290     }
291     return ret;
292 }
293 
UpdateDragStyle(DragCursorStyle style)294 int32_t DeviceStatusSrvProxy::UpdateDragStyle(DragCursorStyle style)
295 {
296     CALL_DEBUG_ENTER;
297     MessageParcel data;
298     if (!data.WriteInterfaceToken(DeviceStatusSrvProxy::GetDescriptor())) {
299         FI_HILOGE("Failed to write descriptor");
300         return ERR_INVALID_VALUE;
301     }
302     WRITEINT32(data, static_cast<int32_t>(style), ERR_INVALID_VALUE);
303     sptr<IRemoteObject> remote = Remote();
304     CHKPR(remote, RET_ERR);
305     MessageParcel reply;
306     MessageOption option;
307     int32_t ret = remote->SendRequest(static_cast<uint32_t>(DeviceInterfaceCode::UPDATED_DRAG_STYLE),
308         data, reply, option);
309     if (ret != RET_OK) {
310         FI_HILOGE("Send request failed, ret:%{public}d", ret);
311     }
312     return ret;
313 }
314 
GetDragTargetPid()315 int32_t DeviceStatusSrvProxy::GetDragTargetPid()
316 {
317     CALL_DEBUG_ENTER;
318     MessageParcel data;
319     if (!data.WriteInterfaceToken(DeviceStatusSrvProxy::GetDescriptor())) {
320         FI_HILOGE("WriteInterfaceToken failed");
321         return ERR_INVALID_VALUE;
322     }
323     sptr<IRemoteObject> remote = Remote();
324     CHKPR(remote, RET_ERR);
325     MessageParcel reply;
326     MessageOption option;
327     int32_t ret = remote->SendRequest(static_cast<uint32_t>(DeviceInterfaceCode::GET_DRAG_TARGET_PID),
328         data, reply, option);
329     if (ret != RET_OK) {
330         FI_HILOGE("Send request failed, ret:%{public}d", ret);
331         return RET_ERR;
332     }
333     int32_t pid = 0;
334     READINT32(reply, pid, IPC_PROXY_DEAD_OBJECT_ERR);
335     return pid;
336 }
337 
GetUdKey(std::string & udKey)338 int32_t DeviceStatusSrvProxy::GetUdKey(std::string &udKey)
339 {
340     CALL_DEBUG_ENTER;
341     MessageParcel data;
342     if (!data.WriteInterfaceToken(DeviceStatusSrvProxy::GetDescriptor())) {
343         FI_HILOGE("WriteInterfaceToken failed");
344         return ERR_INVALID_VALUE;
345     }
346     sptr<IRemoteObject> remote = Remote();
347     CHKPR(remote, RET_ERR);
348     MessageParcel reply;
349     MessageOption option;
350     int32_t ret = remote->SendRequest(static_cast<uint32_t>(DeviceInterfaceCode::GET_DRAG_TARGET_UDKEY),
351         data, reply, option);
352     if (ret != RET_OK) {
353         FI_HILOGE("Send request failed, ret:%{public}d", ret);
354         return RET_ERR;
355     }
356     READSTRING(reply, udKey, IPC_PROXY_DEAD_OBJECT_ERR);
357     return RET_OK;
358 }
359 
GetDragData(DragData & dragData)360 int32_t DeviceStatusSrvProxy::GetDragData(DragData &dragData)
361 {
362     CALL_DEBUG_ENTER;
363     MessageParcel data;
364     if (!data.WriteInterfaceToken(DeviceStatusSrvProxy::GetDescriptor())) {
365         FI_HILOGE("Failed to write descriptor");
366         return ERR_INVALID_VALUE;
367     }
368     sptr<IRemoteObject> remote = Remote();
369     CHKPR(remote, RET_ERR);
370     MessageOption option;
371     MessageParcel reply;
372     int32_t ret = remote->SendRequest(static_cast<uint32_t>(DeviceInterfaceCode::GET_DRAG_DATA), data, reply, option);
373     if (ret != RET_OK) {
374         FI_HILOGE("Send request failed, ret:%{public}d", ret);
375         return ret;
376     }
377     READINT32(reply, ret, IPC_PROXY_DEAD_OBJECT_ERR);
378     if (ret != RET_OK) {
379         FI_HILOGE("Get DragData failed");
380         return ret;
381     }
382     if (DragDataPacker::UnMarshalling(reply, dragData) != RET_OK) {
383         FI_HILOGE("UnMarshalling dragData failed");
384         return RET_ERR;
385     }
386     return ret;
387 }
388 
GetDragState(DragState & dragState)389 int32_t DeviceStatusSrvProxy::GetDragState(DragState &dragState)
390 {
391     CALL_DEBUG_ENTER;
392     MessageParcel data;
393     if (!data.WriteInterfaceToken(DeviceStatusSrvProxy::GetDescriptor())) {
394         FI_HILOGE("Failed to write descriptor");
395         return ERR_INVALID_VALUE;
396     }
397     sptr<IRemoteObject> remote = Remote();
398     CHKPR(remote, RET_ERR);
399     MessageParcel reply;
400     MessageOption option;
401     int32_t ret = remote->SendRequest(static_cast<uint32_t>(DeviceInterfaceCode::GET_DRAG_STATE), data, reply, option);
402     if (ret != RET_OK) {
403         FI_HILOGE("Send request failed, ret:%{public}d", ret);
404         return ret;
405     }
406 
407     int32_t dragStateTmp = 0;
408     READINT32(reply, dragStateTmp, E_DEVICESTATUS_READ_PARCEL_ERROR);
409     dragState = static_cast<DragState>(dragStateTmp);
410     return ret;
411 }
412 
GetCoordinationState(int32_t userData,const std::string & networkId,bool isCompatible)413 int32_t DeviceStatusSrvProxy::GetCoordinationState(int32_t userData,
414     const std::string &networkId, bool isCompatible)
415 {
416     CALL_DEBUG_ENTER;
417     MessageParcel data;
418     if (!data.WriteInterfaceToken(DeviceStatusSrvProxy::GetDescriptor())) {
419         FI_HILOGE("Failed to write descriptor");
420         return ERR_INVALID_VALUE;
421     }
422     WRITEINT32(data, userData, ERR_INVALID_VALUE);
423     WRITESTRING(data, networkId, ERR_INVALID_VALUE);
424     sptr<IRemoteObject> remote = Remote();
425     CHKPR(remote, RET_ERR);
426     MessageParcel reply;
427     MessageOption option;
428     int32_t ret = -1;
429     if (isCompatible) {
430         ret = remote->SendRequest(static_cast<uint32_t>(DeviceInterfaceCode::GET_COOPERATE_STATE),
431             data, reply, option);
432     } else {
433         ret = remote->SendRequest(static_cast<uint32_t>(DeviceInterfaceCode::GET_COORDINATION_STATE),
434             data, reply, option);
435     }
436     if (ret != RET_OK) {
437         FI_HILOGE("Send request failed, ret:%{public}d", ret);
438     }
439     return ret;
440 }
441 
GetCoordinationState(const std::string & udId,bool & state)442 int32_t DeviceStatusSrvProxy::GetCoordinationState(const std::string &udId, bool &state)
443 {
444     CALL_DEBUG_ENTER;
445     MessageParcel data;
446     if (!data.WriteInterfaceToken(DeviceStatusSrvProxy::GetDescriptor())) {
447         FI_HILOGE("Failed to write descriptor");
448         return ERR_INVALID_VALUE;
449     }
450     WRITESTRING(data, udId, ERR_INVALID_VALUE);
451     sptr<IRemoteObject> remote = Remote();
452     CHKPR(remote, RET_ERR);
453     MessageParcel reply;
454     MessageOption option;
455     int32_t ret = remote->SendRequest(static_cast<uint32_t>(DeviceInterfaceCode::GET_COORDINATION_STATE_SYNC),
456         data, reply, option);
457     if (ret != RET_OK) {
458         FI_HILOGE("Send request failed, ret:%{public}d", ret);
459     }
460     READBOOL(reply, state, IPC_PROXY_DEAD_OBJECT_ERR);
461     return ret;
462 }
463 
StartDrag(const DragData & dragData)464 int32_t DeviceStatusSrvProxy::StartDrag(const DragData &dragData)
465 {
466     CALL_DEBUG_ENTER;
467     MessageParcel data;
468     if (!data.WriteInterfaceToken(DeviceStatusSrvProxy::GetDescriptor())) {
469         FI_HILOGE("Failed to write descriptor");
470         return ERR_INVALID_VALUE;
471     }
472     if (DragDataPacker::Marshalling(dragData, data) != RET_OK) {
473         FI_HILOGE("Failed to marshalling dragData");
474         return ERR_INVALID_VALUE;
475     }
476     sptr<IRemoteObject> remote = Remote();
477     CHKPR(remote, RET_ERR);
478     MessageParcel reply;
479     MessageOption option;
480     int32_t ret = remote->SendRequest(static_cast<uint32_t>(DeviceInterfaceCode::START_DRAG),
481         data, reply, option);
482     if (ret != RET_OK) {
483         FI_HILOGE("Send request failed, ret:%{public}d", ret);
484     }
485     READINT32(reply, ret, IPC_PROXY_DEAD_OBJECT_ERR);
486     return ret;
487 }
488 
StopDrag(const DragDropResult & dropResult)489 int32_t DeviceStatusSrvProxy::StopDrag(const DragDropResult &dropResult)
490 {
491     CALL_DEBUG_ENTER;
492     MessageParcel data;
493     if (!data.WriteInterfaceToken(DeviceStatusSrvProxy::GetDescriptor())) {
494         FI_HILOGE("Failed to write descriptor");
495         return ERR_INVALID_VALUE;
496     }
497     if (dropResult.result < DragResult::DRAG_SUCCESS || dropResult.result > DragResult::DRAG_EXCEPTION) {
498         FI_HILOGE("Invalid result:%{public}d", static_cast<int32_t>(dropResult.result));
499         return RET_ERR;
500     }
501     WRITEINT32(data, static_cast<int32_t>(dropResult.result), ERR_INVALID_VALUE);
502     WRITEBOOL(data, dropResult.hasCustomAnimation, ERR_INVALID_VALUE);
503     WRITEINT32(data, dropResult.mainWindow, ERR_INVALID_VALUE);
504     WRITEINT32(data, static_cast<int32_t>(dropResult.dragBehavior), ERR_INVALID_VALUE);
505     sptr<IRemoteObject> remote = Remote();
506     CHKPR(remote, RET_ERR);
507     MessageParcel reply;
508     MessageOption option;
509     int32_t ret = remote->SendRequest(static_cast<uint32_t>(DeviceInterfaceCode::STOP_DRAG),
510         data, reply, option);
511     if (ret != RET_OK) {
512         FI_HILOGE("Send request failed, ret:%{public}d", ret);
513     }
514     READINT32(reply, ret, IPC_PROXY_DEAD_OBJECT_ERR);
515     return ret;
516 }
517 
AllocSocketFd(const std::string & programName,int32_t moduleType,int32_t & socketFd,int32_t & tokenType)518 int32_t DeviceStatusSrvProxy::AllocSocketFd(const std::string &programName, int32_t moduleType,
519     int32_t &socketFd, int32_t &tokenType)
520 {
521     CALL_DEBUG_ENTER;
522     MessageParcel data;
523     if (!data.WriteInterfaceToken(DeviceStatusSrvProxy::GetDescriptor())) {
524         FI_HILOGE("Failed to write descriptor");
525         return ERR_INVALID_VALUE;
526     }
527     WRITEINT32(data, moduleType, ERR_INVALID_VALUE);
528     WRITESTRING(data, programName, ERR_INVALID_VALUE);
529     sptr<IRemoteObject> remote = Remote();
530     CHKPR(remote, RET_ERR);
531     MessageParcel reply;
532     MessageOption option;
533     int32_t ret = remote->SendRequest(static_cast<uint32_t>(DeviceInterfaceCode::ALLOC_SOCKET_FD),
534         data, reply, option);
535     if (ret != RET_OK) {
536         FI_HILOGE("Send request failed, ret:%{public}d", ret);
537         return RET_ERR;
538     }
539     socketFd = reply.ReadFileDescriptor();
540     if (socketFd < RET_OK) {
541         FI_HILOGE("Read file descriptor failed, fd:%{public}d", socketFd);
542         return IPC_PROXY_DEAD_OBJECT_ERR;
543     }
544     READINT32(reply, tokenType, IPC_PROXY_DEAD_OBJECT_ERR);
545     FI_HILOGD("socketFd:%{public}d, tokenType:%{public}d", socketFd, tokenType);
546     return RET_OK;
547 }
548 
AddDraglistener()549 int32_t DeviceStatusSrvProxy::AddDraglistener()
550 {
551     CALL_DEBUG_ENTER;
552     MessageParcel data;
553     if (!data.WriteInterfaceToken(DeviceStatusSrvProxy::GetDescriptor())) {
554         FI_HILOGE("Failed to write descriptor");
555         return ERR_INVALID_VALUE;
556     }
557     sptr<IRemoteObject> remote = Remote();
558     CHKPR(remote, RET_ERR);
559     MessageParcel reply;
560     MessageOption option;
561     int32_t ret = remote->SendRequest(static_cast<uint32_t>(DeviceInterfaceCode::REGISTER_DRAG_MONITOR),
562         data, reply, option);
563     if (ret != RET_OK) {
564         FI_HILOGE("Send request failed, ret:%{public}d", ret);
565     }
566     return ret;
567 }
568 
RemoveDraglistener()569 int32_t DeviceStatusSrvProxy::RemoveDraglistener()
570 {
571     CALL_DEBUG_ENTER;
572     MessageParcel data;
573     if (!data.WriteInterfaceToken(DeviceStatusSrvProxy::GetDescriptor())) {
574         FI_HILOGE("Failed to write descriptor");
575         return ERR_INVALID_VALUE;
576     }
577     sptr<IRemoteObject> remote = Remote();
578     CHKPR(remote, RET_ERR);
579     MessageParcel reply;
580     MessageOption option;
581     int32_t ret = remote->SendRequest(static_cast<uint32_t>(DeviceInterfaceCode::UNREGISTER_DRAG_MONITOR),
582         data, reply, option);
583     if (ret != RET_OK) {
584         FI_HILOGE("Send request failed, ret:%{public}d", ret);
585     }
586     return ret;
587 }
588 
AddSubscriptListener()589 int32_t DeviceStatusSrvProxy::AddSubscriptListener()
590 {
591     CALL_DEBUG_ENTER;
592     MessageParcel data;
593     if (!data.WriteInterfaceToken(DeviceStatusSrvProxy::GetDescriptor())) {
594         FI_HILOGE("Failed to write descriptor");
595         return ERR_INVALID_VALUE;
596     }
597     sptr<IRemoteObject> remote = Remote();
598     CHKPR(remote, RET_ERR);
599     MessageParcel reply;
600     MessageOption option;
601     int32_t ret = remote->SendRequest(static_cast<uint32_t>(DeviceInterfaceCode::REGISTER_SUBSCRIPT_MONITOR),
602         data, reply, option);
603     if (ret != RET_OK) {
604         FI_HILOGE("Send request failed, ret:%{public}d", ret);
605     }
606     return ret;
607 }
608 
RemoveSubscriptListener()609 int32_t DeviceStatusSrvProxy::RemoveSubscriptListener()
610 {
611     CALL_DEBUG_ENTER;
612     MessageParcel data;
613     if (!data.WriteInterfaceToken(DeviceStatusSrvProxy::GetDescriptor())) {
614         FI_HILOGE("Failed to write descriptor");
615         return ERR_INVALID_VALUE;
616     }
617     sptr<IRemoteObject> remote = Remote();
618     CHKPR(remote, RET_ERR);
619     MessageParcel reply;
620     MessageOption option;
621     int32_t ret = remote->SendRequest(static_cast<uint32_t>(DeviceInterfaceCode::UNREGISTER_SUBSCRIPT_MONITOR),
622         data, reply, option);
623     if (ret != RET_OK) {
624         FI_HILOGE("Send request failed, ret:%{public}d", ret);
625     }
626     return ret;
627 }
628 
SetDragWindowVisible(bool visible,bool isForce)629 int32_t DeviceStatusSrvProxy::SetDragWindowVisible(bool visible, bool isForce)
630 {
631     CALL_DEBUG_ENTER;
632     MessageParcel data;
633     if (!data.WriteInterfaceToken(DeviceStatusSrvProxy::GetDescriptor())) {
634         FI_HILOGE("Failed to write descriptor");
635         return ERR_INVALID_VALUE;
636     }
637     WRITEBOOL(data, visible, ERR_INVALID_VALUE);
638     WRITEBOOL(data, isForce, ERR_INVALID_VALUE);
639     sptr<IRemoteObject> remote = Remote();
640     CHKPR(remote, RET_ERR);
641     MessageParcel reply;
642     MessageOption option;
643     int32_t ret = remote->SendRequest(static_cast<uint32_t>(DeviceInterfaceCode::SET_DRAG_WINDOW_VISIBLE),
644         data, reply, option);
645     if (ret != RET_OK) {
646         FI_HILOGE("Send request failed, ret:%{public}d", ret);
647     }
648     return ret;
649 }
650 
GetShadowOffset(ShadowOffset & shadowOffset)651 int32_t DeviceStatusSrvProxy::GetShadowOffset(ShadowOffset &shadowOffset)
652 {
653     CALL_DEBUG_ENTER;
654     MessageParcel data;
655     if (!data.WriteInterfaceToken(DeviceStatusSrvProxy::GetDescriptor())) {
656         FI_HILOGE("Failed to write descriptor");
657         return ERR_INVALID_VALUE;
658     }
659     sptr<IRemoteObject> remote = Remote();
660     CHKPR(remote, RET_ERR);
661     MessageParcel reply;
662     MessageOption option;
663     int32_t ret = remote->SendRequest(static_cast<uint32_t>(DeviceInterfaceCode::GET_SHADOW_OFFSET),
664         data, reply, option);
665     if (ret != RET_OK) {
666         FI_HILOGE("Send request failed, ret:%{public}d", ret);
667     }
668     if (ShadowOffsetPacker::UnMarshalling(reply, shadowOffset) != RET_OK) {
669         FI_HILOGE("UnMarshalling offset failed");
670         return RET_ERR;
671     }
672     return ret;
673 }
674 
UpdateShadowPic(const ShadowInfo & shadowInfo)675 int32_t DeviceStatusSrvProxy::UpdateShadowPic(const ShadowInfo &shadowInfo)
676 {
677     CALL_DEBUG_ENTER;
678     MessageParcel data;
679     if (!data.WriteInterfaceToken(DeviceStatusSrvProxy::GetDescriptor())) {
680         FI_HILOGE("Failed to write descriptor");
681         return ERR_INVALID_VALUE;
682     }
683     if (ShadowPacker::PackUpShadowInfo(shadowInfo, data) != RET_OK) {
684         FI_HILOGE("PackUpShadowInfo failed");
685         return ERR_INVALID_VALUE;
686     }
687     sptr<IRemoteObject> remote = Remote();
688     CHKPR(remote, RET_ERR);
689     MessageParcel reply;
690     MessageOption option;
691     int32_t ret = remote->SendRequest(static_cast<uint32_t>(DeviceInterfaceCode::UPDATE_SHADOW_PIC),
692         data, reply, option);
693     if (ret != RET_OK) {
694         FI_HILOGE("Send request failed, ret:%{public}d", ret);
695     }
696     return ret;
697 }
698 
AddHotAreaListener()699 int32_t DeviceStatusSrvProxy::AddHotAreaListener()
700 {
701     CALL_DEBUG_ENTER;
702     MessageParcel data;
703     if (!data.WriteInterfaceToken(DeviceStatusSrvProxy::GetDescriptor())) {
704         FI_HILOGE("Failed to write descriptor");
705         return ERR_INVALID_VALUE;
706     }
707     sptr<IRemoteObject> remote = Remote();
708     CHKPR(remote, RET_ERR);
709     MessageParcel reply;
710     MessageOption option;
711     int32_t ret = remote->SendRequest(static_cast<uint32_t>(DeviceInterfaceCode::ADD_HOT_AREA_MONITOR),
712         data, reply, option);
713     if (ret != RET_OK) {
714         FI_HILOGE("Send request fail, ret:%{public}d", ret);
715     }
716     return ret;
717 }
718 
RemoveHotAreaListener()719 int32_t DeviceStatusSrvProxy::RemoveHotAreaListener()
720 {
721     CALL_DEBUG_ENTER;
722     MessageParcel data;
723     if (!data.WriteInterfaceToken(DeviceStatusSrvProxy::GetDescriptor())) {
724         FI_HILOGE("Failed to write descriptor");
725         return ERR_INVALID_VALUE;
726     }
727     sptr<IRemoteObject> remote = Remote();
728     CHKPR(remote, RET_ERR);
729     MessageParcel reply;
730     MessageOption option;
731     int32_t ret = remote->SendRequest(static_cast<uint32_t>(DeviceInterfaceCode::REMOVE_HOT_AREA_MONITOR),
732         data, reply, option);
733     if (ret != RET_OK) {
734         FI_HILOGE("Send request failed, ret:%{public}d", ret);
735     }
736     return ret;
737 }
738 
UpdatePreviewStyle(const PreviewStyle & previewStyle)739 int32_t DeviceStatusSrvProxy::UpdatePreviewStyle(const PreviewStyle &previewStyle)
740 {
741     CALL_DEBUG_ENTER;
742     MessageParcel data;
743     if (!data.WriteInterfaceToken(DeviceStatusSrvProxy::GetDescriptor())) {
744         FI_HILOGE("Failed to write descriptor");
745         return ERR_INVALID_VALUE;
746     }
747     if (PreviewStylePacker::Marshalling(previewStyle, data) != RET_OK) {
748         FI_HILOGE("Marshalling previewStyle failed");
749         return RET_ERR;
750     }
751     sptr<IRemoteObject> remote = Remote();
752     CHKPR(remote, RET_ERR);
753     MessageParcel reply;
754     MessageOption option;
755     int32_t ret = remote->SendRequest(static_cast<uint32_t>(DeviceInterfaceCode::UPDATE_PREVIEW_STYLE),
756         data, reply, option);
757     if (ret != RET_OK) {
758         FI_HILOGE("Send request failed, ret:%{public}d", ret);
759     }
760     return ret;
761 }
762 
UpdatePreviewStyleWithAnimation(const PreviewStyle & previewStyle,const PreviewAnimation & animation)763 int32_t DeviceStatusSrvProxy::UpdatePreviewStyleWithAnimation(const PreviewStyle &previewStyle,
764     const PreviewAnimation &animation)
765 {
766     CALL_DEBUG_ENTER;
767     MessageParcel data;
768     if (!data.WriteInterfaceToken(DeviceStatusSrvProxy::GetDescriptor())) {
769         FI_HILOGE("Failed to write descriptor");
770         return ERR_INVALID_VALUE;
771     }
772     if (PreviewStylePacker::Marshalling(previewStyle, data) != RET_OK) {
773         FI_HILOGE("Marshalling previewStyle failed");
774         return RET_ERR;
775     }
776     if (PreviewAnimationPacker::Marshalling(animation, data) != RET_OK) {
777         FI_HILOGE("Marshalling animation failed");
778         return RET_ERR;
779     }
780     sptr<IRemoteObject> remote = Remote();
781     CHKPR(remote, RET_ERR);
782     MessageParcel reply;
783     MessageOption option;
784     int32_t ret = remote->SendRequest(static_cast<uint32_t>(DeviceInterfaceCode::UPDATE_PREVIEW_STYLE_WITH_ANIMATION),
785         data, reply, option);
786     if (ret != RET_OK) {
787         FI_HILOGE("Send request failed, ret:%{public}d", ret);
788     }
789     return ret;
790 }
791 
GetDragSummary(std::map<std::string,int64_t> & summarys)792 int32_t DeviceStatusSrvProxy::GetDragSummary(std::map<std::string, int64_t> &summarys)
793 {
794     CALL_DEBUG_ENTER;
795     MessageParcel data;
796     if (!data.WriteInterfaceToken(DeviceStatusSrvProxy::GetDescriptor())) {
797         FI_HILOGE("Failed to write descriptor");
798         return ERR_INVALID_VALUE;
799     }
800     sptr<IRemoteObject> remote = Remote();
801     CHKPR(remote, RET_ERR);
802     MessageParcel reply;
803     MessageOption option;
804     int32_t ret = remote->SendRequest(static_cast<uint32_t>(DeviceInterfaceCode::GET_DRAG_SUMMARY),
805         data, reply, option);
806     if (ret != RET_OK) {
807         FI_HILOGE("Send request failed, ret:%{public}d", ret);
808         return RET_ERR;
809     }
810     if (SummaryPacker::UnMarshalling(reply, summarys) != RET_OK) {
811         FI_HILOGE("Failed to summarys unmarshalling");
812         return RET_ERR;
813     }
814     return ret;
815 }
816 
GetDragAction(DragAction & dragAction)817 int32_t DeviceStatusSrvProxy::GetDragAction(DragAction &dragAction)
818 {
819     CALL_DEBUG_ENTER;
820     MessageParcel data;
821     if (!data.WriteInterfaceToken(DeviceStatusSrvProxy::GetDescriptor())) {
822         FI_HILOGE("Failed to write descriptor");
823         return ERR_INVALID_VALUE;
824     }
825     sptr<IRemoteObject> remote = Remote();
826     CHKPR(remote, RET_ERR);
827     MessageParcel reply;
828     MessageOption option;
829     int32_t ret = remote->SendRequest(static_cast<uint32_t>(DeviceInterfaceCode::GET_DRAG_ACTION),
830         data, reply, option);
831     if (ret != RET_OK) {
832         FI_HILOGE("Send request failed, ret:%{public}d", ret);
833         return ret;
834     }
835     int32_t type;
836     READINT32(reply, type, IPC_PROXY_DEAD_OBJECT_ERR);
837     dragAction = static_cast<DragAction>(type);
838     return ret;
839 }
840 
EnterTextEditorArea(bool enable)841 int32_t DeviceStatusSrvProxy::EnterTextEditorArea(bool enable)
842 {
843     CALL_DEBUG_ENTER;
844     MessageParcel data;
845     if (!data.WriteInterfaceToken(DeviceStatusSrvProxy::GetDescriptor())) {
846         FI_HILOGE("Failed to write descriptor");
847         return ERR_INVALID_VALUE;
848     }
849     WRITEBOOL(data, enable, ERR_INVALID_VALUE);
850     sptr<IRemoteObject> remote = Remote();
851     CHKPR(remote, RET_ERR);
852     MessageParcel reply;
853     MessageOption option;
854     int32_t ret = remote->SendRequest(static_cast<uint32_t>(DeviceInterfaceCode::ENTER_TEXT_EDITOR_AREA),
855         data, reply, option);
856     if (ret != RET_OK) {
857         FI_HILOGE("Send request failed, ret:%{public}d", ret);
858     }
859     return ret;
860 }
861 
GetExtraInfo(std::string & extraInfo)862 int32_t DeviceStatusSrvProxy::GetExtraInfo(std::string &extraInfo)
863 {
864     CALL_DEBUG_ENTER;
865     MessageParcel data;
866     if (!data.WriteInterfaceToken(DeviceStatusSrvProxy::GetDescriptor())) {
867         FI_HILOGE("Failed to write descriptor");
868         return ERR_INVALID_VALUE;
869     }
870     sptr<IRemoteObject> remote = Remote();
871     CHKPR(remote, RET_ERR);
872     MessageParcel reply;
873     MessageOption option;
874     int32_t ret = remote->SendRequest(static_cast<uint32_t>(DeviceInterfaceCode::GET_DRAG_EXTRAINFO),
875         data, reply, option);
876     if (ret != RET_OK) {
877         FI_HILOGE("Send request failed, ret:%{public}d", ret);
878         return ret;
879     }
880     READSTRING(reply, extraInfo, IPC_PROXY_DEAD_OBJECT_ERR);
881     return ret;
882 }
883 
AddPrivilege()884 int32_t DeviceStatusSrvProxy::AddPrivilege()
885 {
886     CALL_DEBUG_ENTER;
887     MessageParcel data;
888     if (!data.WriteInterfaceToken(DeviceStatusSrvProxy::GetDescriptor())) {
889         FI_HILOGE("Failed to write descriptor");
890         return ERR_INVALID_VALUE;
891     }
892     sptr<IRemoteObject> remote = Remote();
893     CHKPR(remote, RET_ERR);
894     MessageParcel reply;
895     MessageOption option;
896     int32_t ret = remote->SendRequest(static_cast<uint32_t>(DeviceInterfaceCode::ADD_PRIVILEGE),
897         data, reply, option);
898     if (ret != RET_OK) {
899         FI_HILOGE("Send request failed, ret:%{public}d", ret);
900         return ret;
901     }
902     return ret;
903 }
904 
EraseMouseIcon()905 int32_t DeviceStatusSrvProxy::EraseMouseIcon()
906 {
907     CALL_DEBUG_ENTER;
908     MessageParcel data;
909     if (!data.WriteInterfaceToken(DeviceStatusSrvProxy::GetDescriptor())) {
910         FI_HILOGE("Failed to write descriptor");
911         return ERR_INVALID_VALUE;
912     }
913     sptr<IRemoteObject> remote = Remote();
914     CHKPR(remote, RET_ERR);
915     MessageParcel reply;
916     MessageOption option;
917     int32_t ret = remote->SendRequest(static_cast<uint32_t>(DeviceInterfaceCode::ERASE_MOUSE_ICON),
918         data, reply, option);
919     if (ret != RET_OK) {
920         FI_HILOGE("Send request failed, ret:%{public}d", ret);
921         return ret;
922     }
923     return ret;
924 }
925 } // namespace DeviceStatus
926 } // namespace Msdp
927 } // namespace OHOS
928