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