1 /*
2 * Copyright (C) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "accessible_ability_manager_service_proxy.h"
17 #include "accessibility_ability_info_parcel.h"
18 #include "accessibility_caption_parcel.h"
19 #include "accessibility_event_info_parcel.h"
20 #include "hilog_wrapper.h"
21
22 namespace OHOS {
23 namespace Accessibility {
AccessibleAbilityManagerServiceProxy(const sptr<IRemoteObject> & impl)24 AccessibleAbilityManagerServiceProxy::AccessibleAbilityManagerServiceProxy(const sptr<IRemoteObject> &impl)
25 : IRemoteProxy<IAccessibleAbilityManagerService>(impl)
26 {}
27
~AccessibleAbilityManagerServiceProxy()28 AccessibleAbilityManagerServiceProxy::~AccessibleAbilityManagerServiceProxy()
29 {}
30
WriteInterfaceToken(MessageParcel & data)31 bool AccessibleAbilityManagerServiceProxy::WriteInterfaceToken(MessageParcel &data)
32 {
33 HILOG_DEBUG();
34 if (!data.WriteInterfaceToken(IAccessibleAbilityManagerService::GetDescriptor())) {
35 HILOG_ERROR("write interface token failed");
36 return false;
37 }
38 return true;
39 }
40
SendTransactCmd(IAccessibleAbilityManagerService::Message code,MessageParcel & data,MessageParcel & reply,MessageOption & option)41 bool AccessibleAbilityManagerServiceProxy::SendTransactCmd(IAccessibleAbilityManagerService::Message code,
42 MessageParcel &data, MessageParcel &reply, MessageOption &option)
43 {
44 HILOG_DEBUG();
45
46 sptr<IRemoteObject> remote = Remote();
47 if (!remote) {
48 HILOG_ERROR("fail to send transact cmd %{public}d due to remote object", code);
49 return false;
50 }
51 int32_t result = remote->SendRequest(static_cast<uint32_t>(code), data, reply, option);
52 if (result != NO_ERROR) {
53 HILOG_ERROR("receive error transact code %{public}d in transact cmd %{public}d", result, code);
54 return false;
55 }
56 return true;
57 }
58
SendEvent(const AccessibilityEventInfo & uiEvent)59 RetError AccessibleAbilityManagerServiceProxy::SendEvent(const AccessibilityEventInfo &uiEvent)
60 {
61 HILOG_DEBUG();
62 MessageParcel data;
63 MessageParcel reply;
64 MessageOption option(MessageOption::TF_ASYNC);
65 AccessibilityEventInfoParcel eventInfoParcel(uiEvent);
66
67 if (!WriteInterfaceToken(data)) {
68 HILOG_ERROR("fail, connection write Token");
69 return RET_ERR_IPC_FAILED;
70 }
71
72 if (!data.WriteParcelable(&eventInfoParcel)) {
73 HILOG_ERROR("fail, connection write parcelable AccessibilityEventInfo error");
74 return RET_ERR_IPC_FAILED;
75 }
76
77 if (!SendTransactCmd(IAccessibleAbilityManagerService::Message::SEND_EVENT, data, reply, option)) {
78 HILOG_ERROR("SendEvent fail");
79 return RET_ERR_IPC_FAILED;
80 }
81 return RET_OK;
82 }
83
SetCaptionProperty(const AccessibilityConfig::CaptionProperty & caption)84 RetError AccessibleAbilityManagerServiceProxy::SetCaptionProperty(const AccessibilityConfig::CaptionProperty &caption)
85 {
86 HILOG_DEBUG();
87 MessageParcel data;
88 MessageParcel reply;
89 MessageOption option;
90 CaptionPropertyParcel captionParcel(caption);
91
92 if (!WriteInterfaceToken(data)) {
93 HILOG_ERROR("fail, connection write Token");
94 return RET_ERR_IPC_FAILED;
95 }
96
97 if (!data.WriteParcelable(&captionParcel)) {
98 HILOG_ERROR("fail, connection write parcelable Caption Property ");
99 return RET_ERR_IPC_FAILED;
100 }
101
102 if (!SendTransactCmd(IAccessibleAbilityManagerService::Message::SET_CAPTION_PROPERTY, data, reply, option)) {
103 HILOG_ERROR("SetCaptionProperty fail");
104 return RET_ERR_IPC_FAILED;
105 }
106 return static_cast<RetError>(reply.ReadInt32());
107 }
108
SetCaptionState(const bool state)109 RetError AccessibleAbilityManagerServiceProxy::SetCaptionState(const bool state)
110 {
111 HILOG_DEBUG();
112 MessageParcel data;
113 MessageParcel reply;
114 MessageOption option;
115
116 if (!WriteInterfaceToken(data)) {
117 HILOG_ERROR("fail, connection write Token");
118 return RET_ERR_IPC_FAILED;
119 }
120
121 if (!data.WriteBool(state)) {
122 HILOG_ERROR("fail, connection write parcelable Caption State ");
123 return RET_ERR_IPC_FAILED;
124 }
125
126 if (!SendTransactCmd(IAccessibleAbilityManagerService::Message::SET_CAPTION_STATE, data, reply, option)) {
127 HILOG_ERROR("SetCaptionState fail");
128 return RET_ERR_IPC_FAILED;
129 }
130 return static_cast<RetError>(reply.ReadInt32());
131 }
132
RegisterStateObserver(const sptr<IAccessibleAbilityManagerStateObserver> & client)133 uint32_t AccessibleAbilityManagerServiceProxy::RegisterStateObserver(
134 const sptr<IAccessibleAbilityManagerStateObserver> &client)
135 {
136 HILOG_DEBUG();
137 MessageParcel data;
138 MessageParcel reply;
139 MessageOption option;
140
141 if (!client) {
142 HILOG_ERROR("fail, Input client is null");
143 return TRANSACTION_ERR;
144 }
145
146 if (!WriteInterfaceToken(data)) {
147 HILOG_ERROR("fail, connection write Token error");
148 return TRANSACTION_ERR;
149 }
150
151 if (!data.WriteRemoteObject(client->AsObject())) {
152 HILOG_ERROR("fail, connection write client error");
153 return TRANSACTION_ERR;
154 }
155
156 if (!SendTransactCmd(IAccessibleAbilityManagerService::Message::REGISTER_STATE_CALLBACK,
157 data, reply, option)) {
158 HILOG_ERROR("RegisterStateCallback fail");
159 return TRANSACTION_ERR;
160 }
161
162 return reply.ReadUint32();
163 }
164
GetAbilityList(const uint32_t abilityTypes,const int32_t stateType,std::vector<AccessibilityAbilityInfo> & infos)165 RetError AccessibleAbilityManagerServiceProxy::GetAbilityList(const uint32_t abilityTypes, const int32_t stateType,
166 std::vector<AccessibilityAbilityInfo> &infos)
167 {
168 HILOG_DEBUG();
169 MessageParcel data;
170 MessageParcel reply;
171 MessageOption option;
172
173 if (!WriteInterfaceToken(data)) {
174 HILOG_ERROR("fail, connection write Token error");
175 return RET_ERR_IPC_FAILED;
176 }
177
178 if (!data.WriteUint32(abilityTypes)) {
179 HILOG_ERROR("fail, connection write abilityTypes error");
180 return RET_ERR_IPC_FAILED;
181 }
182
183 if (!data.WriteInt32(stateType)) {
184 HILOG_ERROR("fail, connection write stateType error");
185 return RET_ERR_IPC_FAILED;
186 }
187
188 if (!SendTransactCmd(IAccessibleAbilityManagerService::Message::GET_ABILITYLIST,
189 data, reply, option)) {
190 HILOG_ERROR("GetAbilityList fail");
191 return RET_ERR_IPC_FAILED;
192 }
193 // read result
194 int32_t abilityInfoSize = reply.ReadInt32();
195 for (int32_t i = 0; i < abilityInfoSize; i++) {
196 sptr<AccessibilityAbilityInfoParcel> info = reply.ReadStrongParcelable<AccessibilityAbilityInfoParcel>();
197 if (!info) {
198 HILOG_ERROR("ReadStrongParcelable<AccessibilityAbilityInfoParcel> failed");
199 return RET_ERR_IPC_FAILED;
200 }
201 infos.emplace_back(*info);
202 }
203 return static_cast<RetError>(reply.ReadInt32());
204 }
205
RegisterElementOperator(int32_t windowId,const sptr<IAccessibilityElementOperator> & operation)206 RetError AccessibleAbilityManagerServiceProxy::RegisterElementOperator(
207 int32_t windowId, const sptr<IAccessibilityElementOperator> &operation)
208 {
209 HILOG_DEBUG();
210 MessageParcel data;
211 MessageParcel reply;
212 MessageOption option(MessageOption::TF_ASYNC);
213
214 if (!operation) {
215 HILOG_ERROR("fail, Input operation is null");
216 return RET_ERR_INVALID_PARAM;
217 }
218
219 if (!WriteInterfaceToken(data)) {
220 HILOG_ERROR("fail, connection write Token");
221 return RET_ERR_IPC_FAILED;
222 }
223
224 if (!data.WriteInt32(windowId)) {
225 HILOG_ERROR("fail, connection write windowId error");
226 return RET_ERR_IPC_FAILED;
227 }
228
229 if (!data.WriteRemoteObject(operation->AsObject())) {
230 HILOG_ERROR("fail, connection write parcelable operation error");
231 return RET_ERR_IPC_FAILED;
232 }
233
234 if (!SendTransactCmd(IAccessibleAbilityManagerService::Message::REGISTER_INTERACTION_CONNECTION,
235 data, reply, option)) {
236 HILOG_ERROR("RegisterElementOperator fail");
237 return RET_ERR_IPC_FAILED;
238 }
239 return RET_OK;
240 }
241
DeregisterElementOperator(const int32_t windowId)242 RetError AccessibleAbilityManagerServiceProxy::DeregisterElementOperator(const int32_t windowId)
243 {
244 HILOG_DEBUG("windowId(%{public}d)", windowId);
245 MessageParcel data;
246 MessageParcel reply;
247 MessageOption option(MessageOption::TF_ASYNC);
248
249 if (!WriteInterfaceToken(data)) {
250 HILOG_ERROR("fail, connection write Token");
251 return RET_ERR_IPC_FAILED;
252 }
253
254 if (!data.WriteInt32(windowId)) {
255 HILOG_ERROR("fail, connection write userId error");
256 return RET_ERR_IPC_FAILED;
257 }
258
259 if (!SendTransactCmd(IAccessibleAbilityManagerService::Message::DEREGISTER_INTERACTION_CONNECTION,
260 data, reply, option)) {
261 HILOG_ERROR("DeregisterElementOperator fail");
262 return RET_ERR_IPC_FAILED;
263 }
264 return RET_OK;
265 }
266
GetCaptionProperty(AccessibilityConfig::CaptionProperty & caption)267 RetError AccessibleAbilityManagerServiceProxy::GetCaptionProperty(AccessibilityConfig::CaptionProperty &caption)
268 {
269 HILOG_DEBUG();
270 MessageParcel data;
271 MessageParcel reply;
272 MessageOption option;
273 AccessibilityConfig::CaptionProperty property = {};
274 if (!WriteInterfaceToken(data)) {
275 HILOG_ERROR("fail, connection write Token error");
276 return RET_ERR_IPC_FAILED;
277 }
278
279 if (!SendTransactCmd(IAccessibleAbilityManagerService::Message::GET_CAPTION_PROPERTY,
280 data, reply, option)) {
281 HILOG_ERROR("GetCaptionProperty fail");
282 return RET_ERR_IPC_FAILED;
283 }
284 RetError ret = static_cast<RetError>(reply.ReadInt32());
285 if (ret == RET_OK) {
286 caption = *reply.ReadStrongParcelable<CaptionPropertyParcel>();
287 }
288 return ret;
289 }
290
RegisterCaptionObserver(const sptr<IAccessibleAbilityManagerCaptionObserver> & client)291 uint32_t AccessibleAbilityManagerServiceProxy::RegisterCaptionObserver(
292 const sptr<IAccessibleAbilityManagerCaptionObserver> &client)
293 {
294 HILOG_DEBUG();
295 MessageParcel data;
296 MessageParcel reply;
297 MessageOption option;
298
299 if (!client) {
300 HILOG_ERROR("fail, Input client is null");
301 return TRANSACTION_ERR;
302 }
303
304 if (!WriteInterfaceToken(data)) {
305 HILOG_ERROR("fail, connection write Token error");
306 return TRANSACTION_ERR;
307 }
308
309 if (!data.WriteRemoteObject(client->AsObject())) {
310 HILOG_ERROR("fail, connection write client error");
311 return TRANSACTION_ERR;
312 }
313
314 if (!SendTransactCmd(IAccessibleAbilityManagerService::Message::REGISTER_CAPTION_PROPERTY_CALLBACK,
315 data, reply, option)) {
316 HILOG_ERROR("RegisterCaptionPropertyCallback fail");
317 return TRANSACTION_ERR;
318 }
319
320 return reply.ReadUint32();
321 }
322
GetEnabledState()323 bool AccessibleAbilityManagerServiceProxy::GetEnabledState()
324 {
325 HILOG_DEBUG();
326 MessageParcel data;
327 MessageParcel reply;
328 MessageOption option;
329
330 if (!WriteInterfaceToken(data)) {
331 HILOG_ERROR("fail, connection write Token");
332 return false;
333 }
334 if (!SendTransactCmd(IAccessibleAbilityManagerService::Message::GET_ENABLED,
335 data, reply, option)) {
336 HILOG_ERROR("GetEnabledState fail");
337 return false;
338 }
339 return reply.ReadBool();
340 }
341
GetCaptionState(bool & state)342 RetError AccessibleAbilityManagerServiceProxy::GetCaptionState(bool &state)
343 {
344 HILOG_DEBUG();
345 MessageParcel data;
346 MessageParcel reply;
347 MessageOption option;
348
349 if (!WriteInterfaceToken(data)) {
350 HILOG_ERROR("fail, connection write Token");
351 return RET_ERR_IPC_FAILED;
352 }
353 if (!SendTransactCmd(IAccessibleAbilityManagerService::Message::GET_CAPTION_STATE,
354 data, reply, option)) {
355 HILOG_ERROR("GetCaptionState fail");
356 return RET_ERR_IPC_FAILED;
357 }
358 RetError ret = static_cast<RetError>(reply.ReadInt32());
359 if (ret == RET_OK) {
360 state = reply.ReadBool();
361 }
362 return ret;
363 }
364
GetTouchGuideState()365 bool AccessibleAbilityManagerServiceProxy::GetTouchGuideState()
366 {
367 HILOG_DEBUG();
368 MessageParcel data;
369 MessageParcel reply;
370 MessageOption option;
371
372 if (!WriteInterfaceToken(data)) {
373 HILOG_ERROR("fail, connection write Token");
374 return false;
375 }
376 if (!SendTransactCmd(IAccessibleAbilityManagerService::Message::GET_TOUCH_GUIDE_STATE,
377 data, reply, option)) {
378 HILOG_ERROR("GetTouchGuideState fail");
379 return false;
380 }
381 return reply.ReadBool();
382 }
383
GetGestureState()384 bool AccessibleAbilityManagerServiceProxy::GetGestureState()
385 {
386 HILOG_DEBUG();
387 MessageParcel data;
388 MessageParcel reply;
389 MessageOption option;
390
391 if (!WriteInterfaceToken(data)) {
392 HILOG_ERROR("fail, connection write Token");
393 return false;
394 }
395 if (!SendTransactCmd(IAccessibleAbilityManagerService::Message::GET_GESTURE_STATE,
396 data, reply, option)) {
397 HILOG_ERROR("GetGestureState fail");
398 return false;
399 }
400 return reply.ReadBool();
401 }
402
GetKeyEventObserverState()403 bool AccessibleAbilityManagerServiceProxy::GetKeyEventObserverState()
404 {
405 HILOG_DEBUG();
406 MessageParcel data;
407 MessageParcel reply;
408 MessageOption option;
409
410 if (!WriteInterfaceToken(data)) {
411 HILOG_ERROR("fail, connection write Token");
412 return false;
413 }
414 if (!SendTransactCmd(IAccessibleAbilityManagerService::Message::GET_KEY_EVENT_OBSERVE_STATE,
415 data, reply, option)) {
416 HILOG_ERROR("GetKeyEventObserverState fail");
417 return false;
418 }
419 return reply.ReadBool();
420 }
421
EnableAbility(const std::string & name,const uint32_t capabilities)422 RetError AccessibleAbilityManagerServiceProxy::EnableAbility(const std::string &name, const uint32_t capabilities)
423 {
424 HILOG_DEBUG();
425 MessageParcel data;
426 MessageParcel reply;
427 MessageOption option;
428
429 if (!WriteInterfaceToken(data)) {
430 HILOG_ERROR("fail, connection write Token");
431 return RET_ERR_IPC_FAILED;
432 }
433
434 if (!data.WriteString(name)) {
435 HILOG_ERROR("name write error: %{public}s, ", name.c_str());
436 return RET_ERR_IPC_FAILED;
437 }
438
439 if (!data.WriteUint32(capabilities)) {
440 HILOG_ERROR("capabilities write error: %{public}d, ", capabilities);
441 return RET_ERR_IPC_FAILED;
442 }
443
444 if (!SendTransactCmd(IAccessibleAbilityManagerService::Message::ENABLE_ABILITIES,
445 data, reply, option)) {
446 HILOG_ERROR("EnableAbility fail");
447 return RET_ERR_IPC_FAILED;
448 }
449 return static_cast<RetError>(reply.ReadInt32());
450 }
451
GetEnabledAbilities(std::vector<std::string> & enabledAbilities)452 RetError AccessibleAbilityManagerServiceProxy::GetEnabledAbilities(std::vector<std::string> &enabledAbilities)
453 {
454 HILOG_DEBUG();
455 MessageParcel data;
456 MessageParcel reply;
457 MessageOption option;
458
459 if (!WriteInterfaceToken(data)) {
460 HILOG_ERROR("fail, connection write Token error");
461 return RET_ERR_IPC_FAILED;
462 }
463 if (!SendTransactCmd(IAccessibleAbilityManagerService::Message::GET_ENABLED_OBJECT,
464 data, reply, option)) {
465 HILOG_ERROR("GetEnabledAbilities fail");
466 return RET_ERR_IPC_FAILED;
467 }
468
469 int32_t dev_num = reply.ReadInt32();
470 for (int32_t i = 0; i < dev_num; i++) {
471 enabledAbilities.push_back(reply.ReadString());
472 }
473 return static_cast<RetError>(reply.ReadInt32());
474 }
475
DisableAbility(const std::string & name)476 RetError AccessibleAbilityManagerServiceProxy::DisableAbility(const std::string &name)
477 {
478 HILOG_DEBUG();
479 MessageParcel data;
480 MessageParcel reply;
481 MessageOption option;
482
483 if (!WriteInterfaceToken(data)) {
484 HILOG_ERROR("fail, connection write Token");
485 return RET_ERR_IPC_FAILED;
486 }
487
488 if (!data.WriteString(name)) {
489 HILOG_ERROR("name write error: %{public}s, ", name.c_str());
490 return RET_ERR_IPC_FAILED;
491 }
492 if (!SendTransactCmd(IAccessibleAbilityManagerService::Message::DISABLE_ABILITIES,
493 data, reply, option)) {
494 HILOG_ERROR("DisableAbility fail");
495 return RET_ERR_IPC_FAILED;
496 }
497 return static_cast<RetError>(reply.ReadInt32());
498 }
499
GetActiveWindow()500 int32_t AccessibleAbilityManagerServiceProxy::GetActiveWindow()
501 {
502 HILOG_DEBUG();
503 MessageParcel data;
504 MessageParcel reply;
505 MessageOption option;
506
507 if (!WriteInterfaceToken(data)) {
508 HILOG_ERROR("fail, connection write Token");
509 return false;
510 }
511
512 if (!SendTransactCmd(IAccessibleAbilityManagerService::Message::GET_ACTIVE_WINDOW,
513 data, reply, option)) {
514 HILOG_ERROR("GetActiveWindow fail");
515 return false;
516 }
517 return reply.ReadInt32();
518 }
519
EnableUITestAbility(const sptr<IRemoteObject> & obj)520 RetError AccessibleAbilityManagerServiceProxy::EnableUITestAbility(const sptr<IRemoteObject> &obj)
521 {
522 HILOG_DEBUG();
523 MessageParcel data;
524 MessageParcel reply;
525 MessageOption option;
526
527 if (!WriteInterfaceToken(data)) {
528 HILOG_ERROR("fail, connection write Token");
529 return RET_ERR_IPC_FAILED;
530 }
531
532 if (!data.WriteRemoteObject(obj)) {
533 HILOG_ERROR("fail, connection write obj");
534 return RET_ERR_IPC_FAILED;
535 }
536
537 if (!SendTransactCmd(IAccessibleAbilityManagerService::Message::ENABLE_UI_TEST_ABILITY,
538 data, reply, option)) {
539 HILOG_ERROR("EnableUITestAbility fail");
540 return RET_ERR_IPC_FAILED;
541 }
542 RetError result = static_cast<RetError>(reply.ReadInt32());
543 HILOG_DEBUG("enable result is %{public}d", result);
544 return result;
545 }
546
DisableUITestAbility()547 RetError AccessibleAbilityManagerServiceProxy::DisableUITestAbility()
548 {
549 HILOG_DEBUG();
550 MessageParcel data;
551 MessageParcel reply;
552 MessageOption option;
553
554 if (!WriteInterfaceToken(data)) {
555 HILOG_ERROR("fail, connection write Token");
556 return RET_ERR_IPC_FAILED;
557 }
558
559 if (!SendTransactCmd(IAccessibleAbilityManagerService::Message::DISABLE_UI_TEST_ABILITY,
560 data, reply, option)) {
561 HILOG_ERROR("DisableUITestAbility fail");
562 return RET_ERR_IPC_FAILED;
563 }
564 return static_cast<RetError>(reply.ReadInt32());
565 }
566
SetScreenMagnificationState(const bool state)567 RetError AccessibleAbilityManagerServiceProxy::SetScreenMagnificationState(const bool state)
568 {
569 HILOG_DEBUG();
570 MessageParcel data;
571 MessageParcel reply;
572 MessageOption option;
573
574 if (!WriteInterfaceToken(data)) {
575 HILOG_ERROR("fail, connection write Token");
576 return RET_ERR_IPC_FAILED;
577 }
578
579 if (!data.WriteBool(state)) {
580 HILOG_ERROR("fail, connection write parcelable Caption State ");
581 return RET_ERR_IPC_FAILED;
582 }
583
584 if (!SendTransactCmd(IAccessibleAbilityManagerService::Message::SET_SCREENMAGNIFIER_STATE, data, reply, option)) {
585 HILOG_ERROR("SetScreenMagnificationState fail");
586 return RET_ERR_IPC_FAILED;
587 }
588
589 return static_cast<RetError>(reply.ReadInt32());
590 }
591
SetShortKeyState(const bool state)592 RetError AccessibleAbilityManagerServiceProxy::SetShortKeyState(const bool state)
593 {
594 HILOG_DEBUG();
595 MessageParcel data;
596 MessageParcel reply;
597 MessageOption option;
598
599 if (!WriteInterfaceToken(data)) {
600 HILOG_ERROR("fail, connection write Token");
601 return RET_ERR_IPC_FAILED;
602 }
603
604 if (!data.WriteBool(state)) {
605 HILOG_ERROR("fail, connection write parcelable Caption State ");
606 return RET_ERR_IPC_FAILED;
607 }
608
609 if (!SendTransactCmd(IAccessibleAbilityManagerService::Message::SET_SHORTKEY_STATE, data, reply, option)) {
610 HILOG_ERROR("SetShortKeyState fail");
611 return RET_ERR_IPC_FAILED;
612 }
613
614 return static_cast<RetError>(reply.ReadInt32());
615 }
616
SetMouseKeyState(const bool state)617 RetError AccessibleAbilityManagerServiceProxy::SetMouseKeyState(const bool state)
618 {
619 HILOG_DEBUG();
620 MessageParcel data;
621 MessageParcel reply;
622 MessageOption option;
623
624 if (!WriteInterfaceToken(data)) {
625 HILOG_ERROR("fail, connection write Token");
626 return RET_ERR_IPC_FAILED;
627 }
628
629 if (!data.WriteBool(state)) {
630 HILOG_ERROR("fail, connection write parcelable Caption State ");
631 return RET_ERR_IPC_FAILED;
632 }
633
634 if (!SendTransactCmd(IAccessibleAbilityManagerService::Message::SET_MOUSEKEY_STATE, data, reply, option)) {
635 HILOG_ERROR("SetMouseKeyState fail");
636 return RET_ERR_IPC_FAILED;
637 }
638
639 return static_cast<RetError>(reply.ReadInt32());
640 }
641
SetMouseAutoClick(const int32_t time)642 RetError AccessibleAbilityManagerServiceProxy::SetMouseAutoClick(const int32_t time)
643 {
644 HILOG_DEBUG();
645 MessageParcel data;
646 MessageParcel reply;
647 MessageOption option;
648
649 if (!WriteInterfaceToken(data)) {
650 HILOG_ERROR("fail, connection write Token");
651 return RET_ERR_IPC_FAILED;
652 }
653
654 if (!data.WriteInt32(time)) {
655 HILOG_ERROR("fail, connection write SetMouseAutoClick time");
656 return RET_ERR_IPC_FAILED;
657 }
658
659 if (!SendTransactCmd(IAccessibleAbilityManagerService::Message::SET_MOUSEKEY_AUTOCLICK, data, reply, option)) {
660 HILOG_ERROR("SetMouseAutoClick fail");
661 return RET_ERR_IPC_FAILED;
662 }
663
664 return static_cast<RetError>(reply.ReadInt32());
665 }
666
SetShortkeyTarget(const std::string & name)667 RetError AccessibleAbilityManagerServiceProxy::SetShortkeyTarget(const std::string &name)
668 {
669 HILOG_DEBUG();
670 MessageParcel data;
671 MessageParcel reply;
672 MessageOption option;
673
674 if (!WriteInterfaceToken(data)) {
675 HILOG_ERROR("fail, connection write Token");
676 return RET_ERR_IPC_FAILED;
677 }
678
679 if (!data.WriteString(name)) {
680 HILOG_ERROR("fail, connection write SetShortkeyTarget name");
681 return RET_ERR_IPC_FAILED;
682 }
683
684 if (!SendTransactCmd(IAccessibleAbilityManagerService::Message::SET_SHORTKEY_TARGET, data, reply, option)) {
685 HILOG_ERROR("SetShortkeyTarget fail");
686 return RET_ERR_IPC_FAILED;
687 }
688
689 return static_cast<RetError>(reply.ReadInt32());
690 }
691
SetHighContrastTextState(const bool state)692 RetError AccessibleAbilityManagerServiceProxy::SetHighContrastTextState(const bool state)
693 {
694 HILOG_DEBUG();
695 MessageParcel data;
696 MessageParcel reply;
697 MessageOption option;
698
699 if (!WriteInterfaceToken(data)) {
700 HILOG_ERROR("fail, connection write Token");
701 return RET_ERR_IPC_FAILED;
702 }
703
704 if (!data.WriteBool(state)) {
705 HILOG_ERROR("fail, connection write parcelable Caption State ");
706 return RET_ERR_IPC_FAILED;
707 }
708
709 if (!SendTransactCmd(IAccessibleAbilityManagerService::Message::SET_HIGHCONTRASTTEXT_STATE, data, reply, option)) {
710 HILOG_ERROR("SetHighContrastTextState fail");
711 return RET_ERR_IPC_FAILED;
712 }
713
714 return static_cast<RetError>(reply.ReadInt32());
715 }
716
SetInvertColorState(const bool state)717 RetError AccessibleAbilityManagerServiceProxy::SetInvertColorState(const bool state)
718 {
719 HILOG_DEBUG();
720 MessageParcel data;
721 MessageParcel reply;
722 MessageOption option;
723
724 if (!WriteInterfaceToken(data)) {
725 HILOG_ERROR("fail, connection write Token");
726 return RET_ERR_IPC_FAILED;
727 }
728
729 if (!data.WriteBool(state)) {
730 HILOG_ERROR("fail, connection write parcelable Caption State ");
731 return RET_ERR_IPC_FAILED;
732 }
733
734 if (!SendTransactCmd(IAccessibleAbilityManagerService::Message::SET_INVERTCOLOR_STATE, data, reply, option)) {
735 HILOG_ERROR("SetInvertColorState fail");
736 return RET_ERR_IPC_FAILED;
737 }
738
739 return static_cast<RetError>(reply.ReadInt32());
740 }
741
SetAnimationOffState(const bool state)742 RetError AccessibleAbilityManagerServiceProxy::SetAnimationOffState(const bool state)
743 {
744 HILOG_DEBUG();
745 MessageParcel data;
746 MessageParcel reply;
747 MessageOption option;
748
749 if (!WriteInterfaceToken(data)) {
750 HILOG_ERROR("fail, connection write Token");
751 return RET_ERR_IPC_FAILED;
752 }
753
754 if (!data.WriteBool(state)) {
755 HILOG_ERROR("fail, connection write parcelable Caption State ");
756 return RET_ERR_IPC_FAILED;
757 }
758
759 if (!SendTransactCmd(IAccessibleAbilityManagerService::Message::SET_ANIMATIONOFF_STATE, data, reply, option)) {
760 HILOG_ERROR("SetAnimationOffState fail");
761 return RET_ERR_IPC_FAILED;
762 }
763
764 return static_cast<RetError>(reply.ReadInt32());
765 }
766
SetAudioMonoState(const bool state)767 RetError AccessibleAbilityManagerServiceProxy::SetAudioMonoState(const bool state)
768 {
769 HILOG_DEBUG();
770 MessageParcel data;
771 MessageParcel reply;
772 MessageOption option;
773
774 if (!WriteInterfaceToken(data)) {
775 HILOG_ERROR("fail, connection write Token");
776 return RET_ERR_IPC_FAILED;
777 }
778
779 if (!data.WriteBool(state)) {
780 HILOG_ERROR("fail, connection write parcelable Caption State ");
781 return RET_ERR_IPC_FAILED;
782 }
783
784 if (!SendTransactCmd(IAccessibleAbilityManagerService::Message::SET_AUDIOMONO_STATE, data, reply, option)) {
785 HILOG_ERROR("SetAudioMonoState fail");
786 return RET_ERR_IPC_FAILED;
787 }
788
789 return static_cast<RetError>(reply.ReadInt32());
790 }
791
SetDaltonizationColorFilter(const uint32_t filter)792 RetError AccessibleAbilityManagerServiceProxy::SetDaltonizationColorFilter(const uint32_t filter)
793 {
794 HILOG_DEBUG();
795 MessageParcel data;
796 MessageParcel reply;
797 MessageOption option;
798
799 if (!WriteInterfaceToken(data)) {
800 HILOG_ERROR("fail, connection write Token");
801 return RET_ERR_IPC_FAILED;
802 }
803
804 if (!data.WriteUint32(filter)) {
805 HILOG_ERROR("fail, connection write SetDaltonizationColorFilter time");
806 return RET_ERR_IPC_FAILED;
807 }
808
809 if (!SendTransactCmd(IAccessibleAbilityManagerService::Message::SET_DALTONIZATION_COLORFILTER,
810 data, reply, option)) {
811 HILOG_ERROR("SetDaltonizationColorFilter fail");
812 return RET_ERR_IPC_FAILED;
813 }
814
815 return static_cast<RetError>(reply.ReadInt32());
816 }
817
SetContentTimeout(const uint32_t time)818 RetError AccessibleAbilityManagerServiceProxy::SetContentTimeout(const uint32_t time)
819 {
820 HILOG_DEBUG();
821 MessageParcel data;
822 MessageParcel reply;
823 MessageOption option;
824
825 if (!WriteInterfaceToken(data)) {
826 HILOG_ERROR("fail, connection write Token");
827 return RET_ERR_IPC_FAILED;
828 }
829
830 if (!data.WriteUint32(time)) {
831 HILOG_ERROR("fail, connection write SetContentTimeout time");
832 return RET_ERR_IPC_FAILED;
833 }
834
835 if (!SendTransactCmd(IAccessibleAbilityManagerService::Message::SET_CONTENT_TIMEOUT, data, reply, option)) {
836 HILOG_ERROR("SetContentTimeout fail");
837 return RET_ERR_IPC_FAILED;
838 }
839
840 return static_cast<RetError>(reply.ReadInt32());
841 }
842
SetBrightnessDiscount(const float discount)843 RetError AccessibleAbilityManagerServiceProxy::SetBrightnessDiscount(const float discount)
844 {
845 HILOG_DEBUG();
846 MessageParcel data;
847 MessageParcel reply;
848 MessageOption option;
849
850 if (!WriteInterfaceToken(data)) {
851 HILOG_ERROR("fail, connection write Token");
852 return RET_ERR_IPC_FAILED;
853 }
854
855 if (!data.WriteFloat(discount)) {
856 HILOG_ERROR("fail, connection write SetBrightnessDiscount time");
857 return RET_ERR_IPC_FAILED;
858 }
859
860 if (!SendTransactCmd(IAccessibleAbilityManagerService::Message::SET_BRIGHTNESS_DISCOUNT, data, reply, option)) {
861 HILOG_ERROR("SetBrightnessDiscount fail");
862 return RET_ERR_IPC_FAILED;
863 }
864
865 return static_cast<RetError>(reply.ReadInt32());
866 }
867
SetAudioBalance(const float balance)868 RetError AccessibleAbilityManagerServiceProxy::SetAudioBalance(const float balance)
869 {
870 HILOG_DEBUG();
871 MessageParcel data;
872 MessageParcel reply;
873 MessageOption option;
874
875 if (!WriteInterfaceToken(data)) {
876 HILOG_ERROR("fail, connection write Token");
877 return RET_ERR_IPC_FAILED;
878 }
879
880 if (!data.WriteFloat(balance)) {
881 HILOG_ERROR("fail, connection write SetAudioBalance time");
882 return RET_ERR_IPC_FAILED;
883 }
884
885 if (!SendTransactCmd(IAccessibleAbilityManagerService::Message::SET_AUDIO_BALANCE, data, reply, option)) {
886 HILOG_ERROR("SetAudioBalance fail");
887 return RET_ERR_IPC_FAILED;
888 }
889
890 return static_cast<RetError>(reply.ReadInt32());
891 }
892
GetScreenMagnificationState(bool & state)893 RetError AccessibleAbilityManagerServiceProxy::GetScreenMagnificationState(bool &state)
894 {
895 HILOG_DEBUG();
896 MessageParcel data;
897 MessageParcel reply;
898 MessageOption option;
899
900 if (!WriteInterfaceToken(data)) {
901 HILOG_ERROR("fail, connection write Token");
902 return RET_ERR_IPC_FAILED;
903 }
904 if (!SendTransactCmd(IAccessibleAbilityManagerService::Message::GET_SCREENMAGNIFIER_STATE,
905 data, reply, option)) {
906 HILOG_ERROR("GetScreenMagnificationState fail");
907 return RET_ERR_IPC_FAILED;
908 }
909
910 RetError ret = static_cast<RetError>(reply.ReadInt32());
911 if (ret == RET_OK) {
912 state = reply.ReadBool();
913 }
914 return ret;
915 }
916
GetShortKeyState(bool & state)917 RetError AccessibleAbilityManagerServiceProxy::GetShortKeyState(bool &state)
918 {
919 HILOG_DEBUG();
920 MessageParcel data;
921 MessageParcel reply;
922 MessageOption option;
923
924 if (!WriteInterfaceToken(data)) {
925 HILOG_ERROR("fail, connection write Token");
926 return RET_ERR_IPC_FAILED;
927 }
928 if (!SendTransactCmd(IAccessibleAbilityManagerService::Message::GET_SHORTKEY_STATE,
929 data, reply, option)) {
930 HILOG_ERROR("GetShortKeyState fail");
931 return RET_ERR_IPC_FAILED;
932 }
933 RetError ret = static_cast<RetError>(reply.ReadInt32());
934 if (ret == RET_OK) {
935 state = reply.ReadBool();
936 }
937 return ret;
938 }
939
GetMouseKeyState(bool & state)940 RetError AccessibleAbilityManagerServiceProxy::GetMouseKeyState(bool &state)
941 {
942 HILOG_DEBUG();
943 MessageParcel data;
944 MessageParcel reply;
945 MessageOption option;
946
947 if (!WriteInterfaceToken(data)) {
948 HILOG_ERROR("fail, connection write Token");
949 return RET_ERR_IPC_FAILED;
950 }
951 if (!SendTransactCmd(IAccessibleAbilityManagerService::Message::GET_MOUSEKEY_STATE,
952 data, reply, option)) {
953 HILOG_ERROR("GetMouseKeyState fail");
954 return RET_ERR_IPC_FAILED;
955 }
956 RetError ret = static_cast<RetError>(reply.ReadInt32());
957 if (ret == RET_OK) {
958 state = reply.ReadBool();
959 }
960 return ret;
961 }
962
GetMouseAutoClick(int32_t & time)963 RetError AccessibleAbilityManagerServiceProxy::GetMouseAutoClick(int32_t &time)
964 {
965 HILOG_DEBUG();
966 MessageParcel data;
967 MessageParcel reply;
968 MessageOption option;
969
970 if (!WriteInterfaceToken(data)) {
971 HILOG_ERROR("fail, connection write Token");
972 return RET_ERR_IPC_FAILED;
973 }
974 if (!SendTransactCmd(IAccessibleAbilityManagerService::Message::GET_MOUSEKEY_AUTOCLICK,
975 data, reply, option)) {
976 HILOG_ERROR("GetMouseAutoClick fail");
977 return RET_ERR_IPC_FAILED;
978 }
979 RetError ret = static_cast<RetError>(reply.ReadInt32());
980 if (ret == RET_OK) {
981 time = reply.ReadInt32();
982 }
983 return ret;
984 }
985
GetShortkeyTarget(std::string & name)986 RetError AccessibleAbilityManagerServiceProxy::GetShortkeyTarget(std::string &name)
987 {
988 HILOG_DEBUG();
989 MessageParcel data;
990 MessageParcel reply;
991 MessageOption option;
992 if (!WriteInterfaceToken(data)) {
993 HILOG_ERROR("fail, connection write Token");
994 return RET_ERR_IPC_FAILED;
995 }
996 if (!SendTransactCmd(IAccessibleAbilityManagerService::Message::GET_SHORTKEY_TARGET,
997 data, reply, option)) {
998 HILOG_ERROR("GetShortkeyTarget fail");
999 return RET_ERR_IPC_FAILED;
1000 }
1001 RetError ret = static_cast<RetError>(reply.ReadInt32());
1002 if (ret == RET_OK) {
1003 name = reply.ReadString();
1004 }
1005 return ret;
1006 }
1007
GetHighContrastTextState(bool & state)1008 RetError AccessibleAbilityManagerServiceProxy::GetHighContrastTextState(bool &state)
1009 {
1010 HILOG_DEBUG();
1011 MessageParcel data;
1012 MessageParcel reply;
1013 MessageOption option;
1014
1015 if (!WriteInterfaceToken(data)) {
1016 HILOG_ERROR("fail, connection write Token");
1017 return RET_ERR_IPC_FAILED;
1018 }
1019 if (!SendTransactCmd(IAccessibleAbilityManagerService::Message::GET_HIGHCONTRASTTEXT_STATE,
1020 data, reply, option)) {
1021 HILOG_ERROR("GetHighContrastTextState fail");
1022 return RET_ERR_IPC_FAILED;
1023 }
1024 RetError ret = static_cast<RetError>(reply.ReadInt32());
1025 if (ret == RET_OK) {
1026 state = reply.ReadBool();
1027 }
1028 return ret;
1029 }
1030
GetInvertColorState(bool & state)1031 RetError AccessibleAbilityManagerServiceProxy::GetInvertColorState(bool &state)
1032 {
1033 HILOG_DEBUG();
1034 MessageParcel data;
1035 MessageParcel reply;
1036 MessageOption option;
1037
1038 if (!WriteInterfaceToken(data)) {
1039 HILOG_ERROR("fail, connection write Token");
1040 return RET_ERR_IPC_FAILED;
1041 }
1042 if (!SendTransactCmd(IAccessibleAbilityManagerService::Message::GET_INVERTCOLOR_STATE,
1043 data, reply, option)) {
1044 HILOG_ERROR("GetInvertColorState fail");
1045 return RET_ERR_IPC_FAILED;
1046 }
1047 RetError ret = static_cast<RetError>(reply.ReadInt32());
1048 if (ret == RET_OK) {
1049 state = reply.ReadBool();
1050 }
1051 return ret;
1052 }
1053
GetAnimationOffState(bool & state)1054 RetError AccessibleAbilityManagerServiceProxy::GetAnimationOffState(bool &state)
1055 {
1056 HILOG_DEBUG();
1057 MessageParcel data;
1058 MessageParcel reply;
1059 MessageOption option;
1060
1061 if (!WriteInterfaceToken(data)) {
1062 HILOG_ERROR("fail, connection write Token");
1063 return RET_ERR_IPC_FAILED;
1064 }
1065 if (!SendTransactCmd(IAccessibleAbilityManagerService::Message::GET_ANIMATIONOFF_STATE,
1066 data, reply, option)) {
1067 HILOG_ERROR("GetAnimationOffState fail");
1068 return RET_ERR_IPC_FAILED;
1069 }
1070 RetError ret = static_cast<RetError>(reply.ReadInt32());
1071 if (ret == RET_OK) {
1072 state = reply.ReadBool();
1073 }
1074 return ret;
1075 }
1076
GetAudioMonoState(bool & state)1077 RetError AccessibleAbilityManagerServiceProxy::GetAudioMonoState(bool &state)
1078 {
1079 HILOG_DEBUG();
1080 MessageParcel data;
1081 MessageParcel reply;
1082 MessageOption option;
1083
1084 if (!WriteInterfaceToken(data)) {
1085 HILOG_ERROR("fail, connection write Token");
1086 return RET_ERR_IPC_FAILED;
1087 }
1088 if (!SendTransactCmd(IAccessibleAbilityManagerService::Message::GET_AUDIOMONO_STATE,
1089 data, reply, option)) {
1090 HILOG_ERROR("GetAudioMonoState fail");
1091 return RET_ERR_IPC_FAILED;
1092 }
1093 RetError ret = static_cast<RetError>(reply.ReadInt32());
1094 if (ret == RET_OK) {
1095 state = reply.ReadBool();
1096 }
1097 return ret;
1098 }
1099
GetDaltonizationColorFilter(uint32_t & type)1100 RetError AccessibleAbilityManagerServiceProxy::GetDaltonizationColorFilter(uint32_t &type)
1101 {
1102 HILOG_DEBUG();
1103 MessageParcel data;
1104 MessageParcel reply;
1105 MessageOption option;
1106
1107 if (!WriteInterfaceToken(data)) {
1108 HILOG_ERROR("fail, connection write Token");
1109 return RET_ERR_IPC_FAILED;
1110 }
1111 if (!SendTransactCmd(IAccessibleAbilityManagerService::Message::GET_DALTONIZATION_COLORFILTER,
1112 data, reply, option)) {
1113 HILOG_ERROR("GetDaltonizationColorFilter fail");
1114 return RET_ERR_IPC_FAILED;
1115 }
1116 RetError ret = static_cast<RetError>(reply.ReadInt32());
1117 if (ret == RET_OK) {
1118 type = reply.ReadUint32();
1119 }
1120 return ret;
1121 }
1122
GetContentTimeout(uint32_t & timer)1123 RetError AccessibleAbilityManagerServiceProxy::GetContentTimeout(uint32_t &timer)
1124 {
1125 HILOG_DEBUG();
1126 MessageParcel data;
1127 MessageParcel reply;
1128 MessageOption option;
1129
1130 if (!WriteInterfaceToken(data)) {
1131 HILOG_ERROR("fail, connection write Token");
1132 return RET_ERR_IPC_FAILED;
1133 }
1134 if (!SendTransactCmd(IAccessibleAbilityManagerService::Message::GET_CONTENT_TIMEOUT,
1135 data, reply, option)) {
1136 HILOG_ERROR("GetContentTimeout fail");
1137 return RET_ERR_IPC_FAILED;
1138 }
1139 RetError ret = static_cast<RetError>(reply.ReadInt32());
1140 if (ret == RET_OK) {
1141 timer = reply.ReadUint32();
1142 }
1143 return ret;
1144 }
1145
GetBrightnessDiscount(float & brightness)1146 RetError AccessibleAbilityManagerServiceProxy::GetBrightnessDiscount(float &brightness)
1147 {
1148 HILOG_DEBUG();
1149 MessageParcel data;
1150 MessageParcel reply;
1151 MessageOption option;
1152
1153 if (!WriteInterfaceToken(data)) {
1154 HILOG_ERROR("fail, connection write Token");
1155 return RET_ERR_IPC_FAILED;
1156 }
1157 if (!SendTransactCmd(IAccessibleAbilityManagerService::Message::GET_BRIGHTNESS_DISCOUNT,
1158 data, reply, option)) {
1159 HILOG_ERROR("GetBrightnessDiscount fail");
1160 return RET_ERR_IPC_FAILED;
1161 }
1162 RetError ret = static_cast<RetError>(reply.ReadInt32());
1163 if (ret == RET_OK) {
1164 brightness = reply.ReadFloat();
1165 }
1166 return ret;
1167 }
1168
GetAudioBalance(float & balance)1169 RetError AccessibleAbilityManagerServiceProxy::GetAudioBalance(float &balance)
1170 {
1171 HILOG_DEBUG();
1172 MessageParcel data;
1173 MessageParcel reply;
1174 MessageOption option;
1175
1176 if (!WriteInterfaceToken(data)) {
1177 HILOG_ERROR("fail, connection write Token");
1178 return RET_ERR_IPC_FAILED;
1179 }
1180 if (!SendTransactCmd(IAccessibleAbilityManagerService::Message::GET_AUDIO_BALANCE,
1181 data, reply, option)) {
1182 HILOG_ERROR("GetAudioBalance fail");
1183 return RET_ERR_IPC_FAILED;
1184 }
1185 RetError ret = static_cast<RetError>(reply.ReadInt32());
1186 if (ret == RET_OK) {
1187 balance = reply.ReadFloat();
1188 }
1189 return ret;
1190 }
1191
GetAllConfigs(AccessibilityConfigData & configData)1192 void AccessibleAbilityManagerServiceProxy::GetAllConfigs(AccessibilityConfigData& configData)
1193 {
1194 HILOG_DEBUG();
1195 MessageParcel data;
1196 MessageParcel reply;
1197 MessageOption option;
1198
1199 if (!WriteInterfaceToken(data)) {
1200 HILOG_ERROR("fail, connection write Token");
1201 return;
1202 }
1203 if (!SendTransactCmd(IAccessibleAbilityManagerService::Message::GET_ALL_CONFIGS,
1204 data, reply, option)) {
1205 HILOG_ERROR("GetAllConfigs fail");
1206 return;
1207 }
1208 configData.highContrastText_ = reply.ReadBool();
1209 configData.invertColor_ = reply.ReadBool();
1210 configData.animationOff_ = reply.ReadBool();
1211 configData.audioMono_ = reply.ReadBool();
1212 configData.mouseKey_ = reply.ReadBool();
1213 configData.captionState_ = reply.ReadBool();
1214 configData.screenMagnifier_ = reply.ReadBool();
1215 configData.shortkey_ = reply.ReadBool();
1216 configData.mouseAutoClick_ = reply.ReadInt32();
1217 configData.daltonizationColorFilter_ = reply.ReadUint32();
1218 configData.contentTimeout_ = reply.ReadUint32();
1219 configData.brightnessDiscount_ = reply.ReadFloat();
1220 configData.audioBalance_ = reply.ReadFloat();
1221 configData.shortkeyTarget_ = reply.ReadString();
1222 configData.captionProperty_ = *reply.ReadStrongParcelable<CaptionPropertyParcel>();
1223 }
1224
RegisterEnableAbilityListsObserver(const sptr<IAccessibilityEnableAbilityListsObserver> & observer)1225 void AccessibleAbilityManagerServiceProxy::RegisterEnableAbilityListsObserver(
1226 const sptr<IAccessibilityEnableAbilityListsObserver> &observer)
1227 {
1228 HILOG_DEBUG();
1229 MessageParcel data;
1230 MessageParcel reply;
1231 MessageOption option(MessageOption::TF_ASYNC);
1232
1233 if (!observer) {
1234 HILOG_ERROR("observer is nullptr");
1235 return;
1236 }
1237
1238 if (!WriteInterfaceToken(data)) {
1239 HILOG_ERROR("write interface token error");
1240 return;
1241 }
1242
1243 if (!data.WriteRemoteObject(observer->AsObject())) {
1244 HILOG_ERROR("observer write remote object error");
1245 return;
1246 }
1247
1248 if (!SendTransactCmd(IAccessibleAbilityManagerService::Message::REGISTER_ENABLE_ABILITY_LISTS_OBSERVER,
1249 data, reply, option)) {
1250 HILOG_ERROR("RegisterEnableAbilityListsObserver fail");
1251 return;
1252 }
1253 }
1254
RegisterConfigObserver(const sptr<IAccessibleAbilityManagerConfigObserver> & client)1255 uint32_t AccessibleAbilityManagerServiceProxy::RegisterConfigObserver(
1256 const sptr<IAccessibleAbilityManagerConfigObserver> &client)
1257 {
1258 HILOG_DEBUG();
1259 MessageParcel data;
1260 MessageParcel reply;
1261 MessageOption option(MessageOption::TF_SYNC);
1262
1263 if (!client) {
1264 HILOG_ERROR("fail, Input client is null");
1265 return TRANSACTION_ERR;
1266 }
1267
1268 if (!WriteInterfaceToken(data)) {
1269 HILOG_ERROR("fail, connection write Token error");
1270 return TRANSACTION_ERR;
1271 }
1272
1273 if (!data.WriteRemoteObject(client->AsObject())) {
1274 HILOG_ERROR("fail, connection write client error");
1275 return TRANSACTION_ERR;
1276 }
1277
1278 if (!SendTransactCmd(IAccessibleAbilityManagerService::Message::REGISTER_CONFIG_CALLBACK,
1279 data, reply, option)) {
1280 HILOG_ERROR("RegisterStateCallback fail");
1281 return TRANSACTION_ERR;
1282 }
1283
1284 return reply.ReadUint32();
1285 }
1286 } // namespace Accessibility
1287 } // namespace OHOS