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_stub.h"
17 #include "accessibility_ability_info_parcel.h"
18 #include "accessibility_caption_parcel.h"
19 #include "accessibility_event_info_parcel.h"
20 #include "accessibility_ipc_interface_code.h"
21 #include "accesstoken_kit.h"
22 #include "hilog_wrapper.h"
23 #include "ipc_skeleton.h"
24 #include "tokenid_kit.h"
25 
26 #define SWITCH_BEGIN(code) switch (code) {
27 #define SWITCH_CASE(case_code, func) case case_code:\
28     {\
29         result_code = func(data, reply);\
30         break;\
31     }
32 
33 #define SWITCH_END() default:\
34     {\
35         result_code = ERR_CODE_DEFAULT;\
36         HILOG_WARN("AccessibleAbilityManagerServiceStub::OnRemoteRequest, default case, need check.");\
37         break;\
38     }\
39 }
40 
41 #define ACCESSIBILITY_ABILITY_MANAGER_SERVICE_STUB_CASES() \
42     SWITCH_CASE(AccessibilityInterfaceCode::SET_SCREENMAGNIFIER_STATE, HandleSetScreenMagnificationState)\
43     SWITCH_CASE(AccessibilityInterfaceCode::SET_SHORTKEY_STATE, HandleSetShortKeyState)\
44     SWITCH_CASE(AccessibilityInterfaceCode::SET_MOUSEKEY_STATE, HandleSetMouseKeyState)\
45     SWITCH_CASE(AccessibilityInterfaceCode::SET_SHORTKEY_TARGET, HandleSetShortkeyTarget)\
46     SWITCH_CASE(AccessibilityInterfaceCode::SET_MOUSEKEY_AUTOCLICK, HandleSetMouseAutoClick)\
47     SWITCH_CASE(AccessibilityInterfaceCode::SET_INVERTCOLOR_STATE, HandleSetInvertColorState)\
48     SWITCH_CASE(AccessibilityInterfaceCode::SET_HIGHCONTRASTTEXT_STATE, HandleSetHighContrastTextState)\
49     SWITCH_CASE(AccessibilityInterfaceCode::SET_AUDIOMONO_STATE, HandleSetAudioMonoState)\
50     SWITCH_CASE(AccessibilityInterfaceCode::SET_ANIMATIONOFF_STATE, HandleSetAnimationOffState)\
51     SWITCH_CASE(AccessibilityInterfaceCode::SET_DALTONIZATION_STATE, HandleSetDaltonizationState)\
52     SWITCH_CASE(AccessibilityInterfaceCode::SET_DALTONIZATION_COLORFILTER, HandleSetDaltonizationColorFilter)\
53     SWITCH_CASE(AccessibilityInterfaceCode::SET_CONTENT_TIMEOUT, HandleSetContentTimeout)\
54     SWITCH_CASE(AccessibilityInterfaceCode::SET_BRIGHTNESS_DISCOUNT, HandleSetBrightnessDiscount)\
55     SWITCH_CASE(AccessibilityInterfaceCode::SET_AUDIO_BALANCE, HandleSetAudioBalance)\
56     SWITCH_CASE(AccessibilityInterfaceCode::SET_CAPTION_PROPERTY, HandleSetCaptionProperty)\
57     SWITCH_CASE(AccessibilityInterfaceCode::SET_CAPTION_STATE, HandleSetCaptionState)\
58     SWITCH_CASE(AccessibilityInterfaceCode::SET_CLICK_RESPONSE_TIME, HandleSetClickResponseTime)\
59     SWITCH_CASE(AccessibilityInterfaceCode::SET_IGNORE_REPEAT_CLICK_STATE, HandleSetIgnoreRepeatClickState)\
60     SWITCH_CASE(AccessibilityInterfaceCode::SET_IGNORE_REPEAT_CLICK_TIME, HandleSetIgnoreRepeatClickTime)\
61     SWITCH_CASE(AccessibilityInterfaceCode::GET_CLICK_RESPONSE_TIME, HandleGetClickResponseTime)\
62     SWITCH_CASE(AccessibilityInterfaceCode::GET_IGNORE_REPEAT_CLICK_STATE, HandleGetIgnoreRepeatClickState)\
63     SWITCH_CASE(AccessibilityInterfaceCode::GET_IGNORE_REPEAT_CLICK_TIME, HandleGetIgnoreRepeatClickTime)\
64     SWITCH_CASE(AccessibilityInterfaceCode::SET_SHORTKEY_MULTI_TARGET, HandleSetShortkeyMultiTarget)\
65     SWITCH_CASE(AccessibilityInterfaceCode::GET_SCREENMAGNIFIER_STATE, HandleGetScreenMagnificationState)\
66     SWITCH_CASE(AccessibilityInterfaceCode::GET_SHORTKEY_STATE, HandleGetShortKeyState)\
67     SWITCH_CASE(AccessibilityInterfaceCode::GET_MOUSEKEY_STATE, HandleGetMouseKeyState)\
68     SWITCH_CASE(AccessibilityInterfaceCode::GET_SHORTKEY_TARGET, HandleGetShortkeyTarget)\
69     SWITCH_CASE(AccessibilityInterfaceCode::GET_MOUSEKEY_AUTOCLICK, HandleGetMouseAutoClick)\
70     SWITCH_CASE(AccessibilityInterfaceCode::GET_INVERTCOLOR_STATE, HandleGetInvertColorState)\
71     SWITCH_CASE(AccessibilityInterfaceCode::GET_HIGHCONTRASTTEXT_STATE, HandleGetHighContrastTextState)\
72     SWITCH_CASE(AccessibilityInterfaceCode::GET_AUDIOMONO_STATE, HandleGetAudioMonoState)\
73     SWITCH_CASE(AccessibilityInterfaceCode::GET_ANIMATIONOFF_STATE, HandleGetAnimationOffState)\
74     SWITCH_CASE(AccessibilityInterfaceCode::GET_DALTONIZATION_STATE, HandleGetDaltonizationState)\
75     SWITCH_CASE(AccessibilityInterfaceCode::GET_DALTONIZATION_COLORFILTER, HandleGetDaltonizationColorFilter)\
76     SWITCH_CASE(AccessibilityInterfaceCode::GET_CONTENT_TIMEOUT, HandleGetContentTimeout)\
77     SWITCH_CASE(AccessibilityInterfaceCode::GET_BRIGHTNESS_DISCOUNT, HandleGetBrightnessDiscount)\
78     SWITCH_CASE(AccessibilityInterfaceCode::GET_AUDIO_BALANCE, HandleGetAudioBalance)\
79     SWITCH_CASE(AccessibilityInterfaceCode::GET_ALL_CONFIGS, HandleGetAllConfigs)\
80     SWITCH_CASE(AccessibilityInterfaceCode::REGISTER_CONFIG_CALLBACK, HandleRegisterConfigCallback)\
81     SWITCH_CASE(AccessibilityInterfaceCode::GET_CAPTION_PROPERTY, HandleGetCaptionProperty)\
82     SWITCH_CASE(AccessibilityInterfaceCode::GET_CAPTION_STATE, HandleGetCaptionState)\
83     SWITCH_CASE(AccessibilityInterfaceCode::GET_WINDOW_AND_ELEMENT_ID, HandleGetWindowAndElementId)\
84     SWITCH_CASE(AccessibilityInterfaceCode::GET_SCENE_BOARD_INNER_WINDOW_ID, HandleGetSceneBoardInnerWinId)\
85     SWITCH_CASE(AccessibilityInterfaceCode::GET_SHORTKEY_MULTI_TARGET, HandleGetShortkeyMultiTarget)\
86     SWITCH_CASE(AccessibilityInterfaceCode::SEND_EVENT, HandleSendEvent)\
87     SWITCH_CASE(AccessibilityInterfaceCode::REGISTER_STATE_CALLBACK, HandleRegisterStateCallback)\
88     SWITCH_CASE(AccessibilityInterfaceCode::GET_ABILITYLIST, HandleGetAbilityList)\
89     SWITCH_CASE(AccessibilityInterfaceCode::REGISTER_INTERACTION_CONNECTION, HandleRegisterAccessibilityElementOperator)\
90     SWITCH_CASE( \
91         AccessibilityInterfaceCode::CARDREGISTER_INTERACTION_CONNECTION, HandleMultiRegisterAccessibilityElementOperator)\
92     SWITCH_CASE( \
93         AccessibilityInterfaceCode::DEREGISTER_INTERACTION_CONNECTION, HandleDeregisterAccessibilityElementOperator)\
94     SWITCH_CASE(AccessibilityInterfaceCode::CARDDEREGISTER_INTERACTION_CONNECTION, \
95         HandleMultiDeregisterAccessibilityElementOperator)\
96     SWITCH_CASE(AccessibilityInterfaceCode::GET_ENABLED, HandleGetEnabled)\
97     SWITCH_CASE(AccessibilityInterfaceCode::GET_TOUCH_GUIDE_STATE, HandleGetTouchGuideState)\
98     SWITCH_CASE(AccessibilityInterfaceCode::GET_GESTURE_STATE, HandleGetGestureState)\
99     SWITCH_CASE(AccessibilityInterfaceCode::GET_KEY_EVENT_OBSERVE_STATE, HandleGetKeyEventObserverState)\
100     SWITCH_CASE(AccessibilityInterfaceCode::ENABLE_ABILITIES, HandleEnableAbility)\
101     SWITCH_CASE(AccessibilityInterfaceCode::GET_ENABLED_OBJECT, HandleGetEnabledAbilities)\
102     SWITCH_CASE(AccessibilityInterfaceCode::DISABLE_ABILITIES, HandleDisableAbility)\
103     SWITCH_CASE(AccessibilityInterfaceCode::REGISTER_CAPTION_PROPERTY_CALLBACK, HandleRegisterCaptionPropertyCallback)\
104     SWITCH_CASE(AccessibilityInterfaceCode::ENABLE_UI_TEST_ABILITY, HandleEnableUITestAbility)\
105     SWITCH_CASE(AccessibilityInterfaceCode::DISABLE_UI_TEST_ABILITY, HandleDisableUITestAbility)\
106     SWITCH_CASE(AccessibilityInterfaceCode::GET_ACTIVE_WINDOW, HandleGetActiveWindow)\
107     SWITCH_CASE( \
108         AccessibilityInterfaceCode::REGISTER_ENABLE_ABILITY_LISTS_OBSERVER, HandleRegisterEnableAbilityListsObserver)\
109     SWITCH_CASE(AccessibilityInterfaceCode::GET_FOCUSED_WINDOW_ID, HandleGetFocusedWindowId)\
110     SWITCH_CASE(AccessibilityInterfaceCode::REMOVE_REQUEST_ID, HandleRemoveRequestId)\
111     SWITCH_CASE(AccessibilityInterfaceCode::GET_ROOT_PARENT_ID, HandleGetRootParentId) \
112     SWITCH_CASE(AccessibilityInterfaceCode::GET_ALL_TREE_ID, HandleGetAllTreeId) \
113 
114 namespace OHOS {
115 namespace Accessibility {
116 using namespace Security::AccessToken;
117 constexpr int32_t IS_EXTERNAL = 1;
118 constexpr int32_t ERR_CODE_DEFAULT = -1000;
119 
AccessibleAbilityManagerServiceStub()120 AccessibleAbilityManagerServiceStub::AccessibleAbilityManagerServiceStub()
121 {
122 }
123 
~AccessibleAbilityManagerServiceStub()124 AccessibleAbilityManagerServiceStub::~AccessibleAbilityManagerServiceStub()
125 {
126 }
127 
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)128 int AccessibleAbilityManagerServiceStub::OnRemoteRequest(
129     uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
130 {
131     HILOG_DEBUG("AccessibleAbilityManagerServiceClientStub::OnRemoteRequest, cmd = %{public}u, flags= %{public}d",
132         code, option.GetFlags());
133     std::u16string descriptor = AccessibleAbilityManagerServiceStub::GetDescriptor();
134     std::u16string remoteDescriptor = data.ReadInterfaceToken();
135     if (descriptor != remoteDescriptor) {
136         HILOG_ERROR("AccessibleAbilityManagerServiceClientStub::OnRemoteRequest,"
137             "local descriptor is not equal to remote");
138         return ERR_INVALID_STATE;
139     }
140 
141     ErrCode result_code = ERR_NONE;
142     SWITCH_BEGIN(code)
143     ACCESSIBILITY_ABILITY_MANAGER_SERVICE_STUB_CASES()
144     SWITCH_END()
145 
146     if (result_code != ERR_CODE_DEFAULT) {
147         return result_code;
148     }
149 
150     return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
151 }
152 
CheckPermission(const std::string & permission) const153 bool AccessibleAbilityManagerServiceStub::CheckPermission(const std::string &permission) const
154 {
155     HILOG_DEBUG();
156     uint32_t callerToken = IPCSkeleton::GetCallingTokenID();
157     int result = TypePermissionState::PERMISSION_GRANTED;
158     ATokenTypeEnum tokenType = AccessTokenKit::GetTokenTypeFlag(callerToken);
159     if (tokenType == TOKEN_INVALID) {
160         HILOG_WARN("AccessToken type invalid!");
161         return false;
162     } else {
163         result = AccessTokenKit::VerifyAccessToken(callerToken, permission);
164     }
165     if (result == TypePermissionState::PERMISSION_DENIED) {
166         HILOG_WARN("AccessTokenID denied!");
167         return false;
168     }
169     HILOG_DEBUG("tokenType %{private}d dAccessTokenID:%{private}u, permission:%{private}s matched!",
170         tokenType, callerToken, permission.c_str());
171     return true;
172 }
173 
IsSystemApp() const174 bool AccessibleAbilityManagerServiceStub::IsSystemApp() const
175 {
176     HILOG_DEBUG();
177 
178     AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID();
179     ATokenTypeEnum tokenType = AccessTokenKit::GetTokenTypeFlag(callerToken);
180     if (tokenType != TOKEN_HAP) {
181         HILOG_INFO("Caller is not a application.");
182         return true;
183     }
184     uint64_t accessTokenId = IPCSkeleton::GetCallingFullTokenID();
185     bool isSystemApplication = TokenIdKit::IsSystemAppByFullTokenID(accessTokenId);
186     return isSystemApplication;
187 }
188 
IsApp() const189 bool AccessibleAbilityManagerServiceStub::IsApp() const
190 {
191     HILOG_DEBUG();
192 
193     AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID();
194     ATokenTypeEnum tokenType = AccessTokenKit::GetTokenTypeFlag(callerToken);
195     if (tokenType == TOKEN_HAP) {
196         HILOG_DEBUG("caller is an application");
197         return true;
198     }
199     return false;
200 }
201 
HandleSendEvent(MessageParcel & data,MessageParcel & reply)202 ErrCode AccessibleAbilityManagerServiceStub::HandleSendEvent(MessageParcel &data, MessageParcel &reply)
203 {
204     HILOG_DEBUG();
205 
206     sptr<AccessibilityEventInfoParcel> uiEvent = data.ReadStrongParcelable<AccessibilityEventInfoParcel>();
207     if (uiEvent == nullptr) {
208         HILOG_DEBUG("ReadStrongParcelable<AbilityInfo> failed");
209         return TRANSACTION_ERR;
210     }
211     SendEvent(*uiEvent, IS_EXTERNAL);
212 
213     return NO_ERROR;
214 }
215 
HandleRegisterStateCallback(MessageParcel & data,MessageParcel & reply)216 ErrCode AccessibleAbilityManagerServiceStub::HandleRegisterStateCallback(
217     MessageParcel &data, MessageParcel &reply)
218 {
219     HILOG_DEBUG();
220 
221     sptr<IRemoteObject> obj = data.ReadRemoteObject();
222     if (obj == nullptr) {
223         HILOG_ERROR("obj is nullptr.");
224         return ERR_INVALID_VALUE;
225     }
226 
227     sptr<IAccessibleAbilityManagerStateObserver> client = iface_cast<IAccessibleAbilityManagerStateObserver>(obj);
228     if (client == nullptr) {
229         HILOG_ERROR("client is nullptr");
230         return ERR_INVALID_VALUE;
231     }
232     uint64_t result = RegisterStateObserver(client);
233     reply.WriteUint64(result);
234 
235     return NO_ERROR;
236 }
237 
HandleGetAbilityList(MessageParcel & data,MessageParcel & reply)238 ErrCode AccessibleAbilityManagerServiceStub::HandleGetAbilityList(MessageParcel &data, MessageParcel &reply)
239 {
240     HILOG_DEBUG();
241 
242     uint32_t abilityTypes = data.ReadUint32();
243     int32_t stateType = data.ReadInt32();
244     std::vector<AccessibilityAbilityInfo> abilityInfos {};
245     RetError result = GetAbilityList(abilityTypes, stateType, abilityInfos);
246 
247     int32_t abilityInfoSize = static_cast<int32_t>(abilityInfos.size());
248     reply.WriteInt32(abilityInfoSize);
249     for (auto &abilityInfo : abilityInfos) {
250         sptr<AccessibilityAbilityInfoParcel> info = new(std::nothrow) AccessibilityAbilityInfoParcel(abilityInfo);
251         if (info == nullptr) {
252             HILOG_ERROR("Failed to create info.");
253             return ERR_NULL_OBJECT;
254         }
255         if (!reply.WriteStrongParcelable(info)) {
256             HILOG_ERROR("WriteStrongParcelable<AccessibilityAbilityInfoParcel> failed");
257             return TRANSACTION_ERR;
258         }
259     }
260     reply.WriteInt32(static_cast<int32_t>(result));
261     return NO_ERROR;
262 }
263 
HandleRegisterAccessibilityElementOperator(MessageParcel & data,MessageParcel & reply)264 ErrCode AccessibleAbilityManagerServiceStub::HandleRegisterAccessibilityElementOperator(
265     MessageParcel &data, MessageParcel &reply)
266 {
267     HILOG_DEBUG();
268 
269     int32_t windowId = data.ReadInt32();
270     sptr<IRemoteObject> obj = data.ReadRemoteObject();
271     sptr<IAccessibilityElementOperator> operation = iface_cast<IAccessibilityElementOperator>(obj);
272     if (operation == nullptr) {
273         HILOG_ERROR("iface_cast obj failed");
274         return TRANSACTION_ERR;
275     }
276     bool isApp = IsApp();
277     RegisterElementOperator(windowId, operation, isApp);
278 
279     return NO_ERROR;
280 }
281 
HandleMultiRegisterAccessibilityElementOperator(MessageParcel & data,MessageParcel & reply)282 ErrCode AccessibleAbilityManagerServiceStub::HandleMultiRegisterAccessibilityElementOperator(
283     MessageParcel &data, MessageParcel &reply)
284 {
285     HILOG_DEBUG();
286 
287     Registration parameter;
288     parameter.windowId = data.ReadInt32();
289     parameter.parentWindowId = data.ReadInt32();
290     parameter.parentTreeId = data.ReadInt32();
291     parameter.elementId = data.ReadInt64();
292 
293     sptr<IRemoteObject> obj = data.ReadRemoteObject();
294     sptr<IAccessibilityElementOperator> operation = iface_cast<IAccessibilityElementOperator>(obj);
295     if (operation == nullptr) {
296         HILOG_ERROR("iface_cast obj failed");
297         return TRANSACTION_ERR;
298     }
299     bool isApp = IsApp();
300     RegisterElementOperator(parameter, operation, isApp);
301 
302     return NO_ERROR;
303 }
304 
HandleDeregisterAccessibilityElementOperator(MessageParcel & data,MessageParcel & reply)305 ErrCode AccessibleAbilityManagerServiceStub::HandleDeregisterAccessibilityElementOperator(
306     MessageParcel &data, MessageParcel &reply)
307 {
308     HILOG_DEBUG();
309 
310     int32_t windowId = data.ReadInt32();
311     DeregisterElementOperator(windowId);
312 
313     return NO_ERROR;
314 }
315 
HandleMultiDeregisterAccessibilityElementOperator(MessageParcel & data,MessageParcel & reply)316 ErrCode AccessibleAbilityManagerServiceStub::HandleMultiDeregisterAccessibilityElementOperator(
317     MessageParcel &data, MessageParcel &reply)
318 {
319     HILOG_DEBUG();
320 
321     int32_t windowId = data.ReadInt32();
322     int32_t treeId = data.ReadInt32();
323     DeregisterElementOperator(windowId, treeId);
324 
325     return NO_ERROR;
326 }
327 
HandleGetCaptionProperty(MessageParcel & data,MessageParcel & reply)328 ErrCode AccessibleAbilityManagerServiceStub::HandleGetCaptionProperty(MessageParcel &data, MessageParcel &reply)
329 {
330     HILOG_DEBUG();
331 
332     if (!IsSystemApp()) {
333         HILOG_WARN("Not system app");
334         reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
335         return NO_ERROR;
336     }
337     AccessibilityConfig::CaptionProperty caption = {};
338     RetError ret = GetCaptionProperty(caption);
339     reply.WriteInt32(ret);
340     if (ret == RET_OK) {
341         CaptionPropertyParcel captionParcel(caption);
342         reply.WriteParcelable(&captionParcel);
343     }
344 
345     return NO_ERROR;
346 }
347 
HandleSetCaptionProperty(MessageParcel & data,MessageParcel & reply)348 ErrCode AccessibleAbilityManagerServiceStub::HandleSetCaptionProperty(MessageParcel &data, MessageParcel &reply)
349 {
350     HILOG_DEBUG();
351 
352     if (!IsSystemApp()) {
353         HILOG_WARN("HandleSetCaptionProperty Not system app");
354         reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
355         return NO_ERROR;
356     }
357     if (!CheckPermission(OHOS_PERMISSION_WRITE_ACCESSIBILITY_CONFIG)) {
358         HILOG_WARN("HandleSetCaptionProperty permission denied.");
359         reply.WriteInt32(RET_ERR_NO_PERMISSION);
360         return NO_ERROR;
361     }
362     sptr<CaptionPropertyParcel> caption = data.ReadStrongParcelable<CaptionPropertyParcel>();
363     if (caption == nullptr) {
364         HILOG_ERROR("ReadStrongParcelable<CaptionProperty> failed");
365         reply.WriteInt32(RET_ERR_IPC_FAILED);
366         return TRANSACTION_ERR;
367     }
368     reply.WriteInt32(SetCaptionProperty(*caption));
369 
370     return NO_ERROR;
371 }
372 
HandleSetCaptionState(MessageParcel & data,MessageParcel & reply)373 ErrCode AccessibleAbilityManagerServiceStub::HandleSetCaptionState(MessageParcel &data, MessageParcel &reply)
374 {
375     HILOG_DEBUG();
376 
377     if (!IsSystemApp()) {
378         HILOG_WARN("HandleSetCaptionState Not system app");
379         reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
380         return NO_ERROR;
381     }
382     if (!CheckPermission(OHOS_PERMISSION_WRITE_ACCESSIBILITY_CONFIG)) {
383         HILOG_WARN("HandleSetCaptionState permission denied.");
384         reply.WriteInt32(RET_ERR_NO_PERMISSION);
385         return NO_ERROR;
386     }
387     bool state = data.ReadBool();
388     reply.WriteInt32(SetCaptionState(state));
389 
390     return NO_ERROR;
391 }
392 
HandleRegisterCaptionPropertyCallback(MessageParcel & data,MessageParcel & reply)393 ErrCode AccessibleAbilityManagerServiceStub::HandleRegisterCaptionPropertyCallback(
394     MessageParcel &data, MessageParcel &reply)
395 {
396     HILOG_DEBUG();
397 
398     sptr<IRemoteObject> remote = data.ReadRemoteObject();
399     sptr<IAccessibleAbilityManagerCaptionObserver> observer =
400         iface_cast<IAccessibleAbilityManagerCaptionObserver>(remote);
401     uint64_t result = RegisterCaptionObserver(observer);
402     reply.WriteUint64(result);
403 
404     return NO_ERROR;
405 }
406 
HandleGetEnabled(MessageParcel & data,MessageParcel & reply)407 ErrCode AccessibleAbilityManagerServiceStub::HandleGetEnabled(MessageParcel &data, MessageParcel &reply)
408 {
409     HILOG_DEBUG();
410 
411     bool result = GetEnabledState();
412     reply.WriteBool(result);
413 
414     return NO_ERROR;
415 }
416 
HandleGetCaptionState(MessageParcel & data,MessageParcel & reply)417 ErrCode AccessibleAbilityManagerServiceStub::HandleGetCaptionState(MessageParcel &data, MessageParcel &reply)
418 {
419     HILOG_DEBUG();
420 
421     if (!IsSystemApp()) {
422         HILOG_WARN("Not system app");
423         reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
424         return NO_ERROR;
425     }
426     bool result = false;
427     RetError ret = GetCaptionState(result);
428     reply.WriteInt32(ret);
429     if (ret == RET_OK) {
430         reply.WriteBool(result);
431     }
432     return NO_ERROR;
433 }
434 
HandleGetTouchGuideState(MessageParcel & data,MessageParcel & reply)435 ErrCode AccessibleAbilityManagerServiceStub::HandleGetTouchGuideState(MessageParcel &data, MessageParcel &reply)
436 {
437     HILOG_DEBUG();
438 
439     bool result = GetTouchGuideState();
440     reply.WriteBool(result);
441     return NO_ERROR;
442 }
443 
HandleGetGestureState(MessageParcel & data,MessageParcel & reply)444 ErrCode AccessibleAbilityManagerServiceStub::HandleGetGestureState(MessageParcel &data, MessageParcel &reply)
445 {
446     HILOG_DEBUG();
447 
448     bool result = GetGestureState();
449     reply.WriteBool(result);
450     return NO_ERROR;
451 }
452 
HandleGetKeyEventObserverState(MessageParcel & data,MessageParcel & reply)453 ErrCode AccessibleAbilityManagerServiceStub::HandleGetKeyEventObserverState(
454     MessageParcel &data, MessageParcel &reply)
455 {
456     HILOG_DEBUG();
457 
458     bool result = GetKeyEventObserverState();
459     reply.WriteBool(result);
460 
461     return NO_ERROR;
462 }
463 
HandleEnableAbility(MessageParcel & data,MessageParcel & reply)464 ErrCode AccessibleAbilityManagerServiceStub::HandleEnableAbility(MessageParcel &data, MessageParcel &reply)
465 {
466     HILOG_DEBUG();
467 
468     if (!IsSystemApp()) {
469         HILOG_WARN("HandleEnableAbility Not system app");
470         reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
471         return NO_ERROR;
472     }
473     if (!CheckPermission(OHOS_PERMISSION_WRITE_ACCESSIBILITY_CONFIG)) {
474         HILOG_WARN("HandleEnableAbility permission denied.");
475         reply.WriteInt32(RET_ERR_NO_PERMISSION);
476         return NO_ERROR;
477     }
478     std::string name = data.ReadString();
479     uint32_t capabilities = data.ReadUint32();
480     RetError result = EnableAbility(name, capabilities);
481     reply.WriteInt32(result);
482     return NO_ERROR;
483 }
484 
HandleGetEnabledAbilities(MessageParcel & data,MessageParcel & reply)485 ErrCode AccessibleAbilityManagerServiceStub::HandleGetEnabledAbilities(MessageParcel &data, MessageParcel &reply)
486 {
487     HILOG_DEBUG();
488 
489     std::vector<std::string> enabledAbilities;
490     RetError result = GetEnabledAbilities(enabledAbilities);
491     reply.WriteInt32(enabledAbilities.size());
492     for (auto &ability : enabledAbilities) {
493         if (!reply.WriteString(ability)) {
494             HILOG_ERROR("ability write error: %{public}s, ", ability.c_str());
495             return TRANSACTION_ERR;
496         }
497     }
498     reply.WriteInt32(result);
499     return NO_ERROR;
500 }
501 
HandleDisableAbility(MessageParcel & data,MessageParcel & reply)502 ErrCode AccessibleAbilityManagerServiceStub::HandleDisableAbility(MessageParcel &data, MessageParcel &reply)
503 {
504     HILOG_DEBUG();
505 
506     if (!IsSystemApp()) {
507         HILOG_WARN("HandleDisableAbility Not system app");
508         reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
509         return NO_ERROR;
510     }
511     if (!CheckPermission(OHOS_PERMISSION_WRITE_ACCESSIBILITY_CONFIG)) {
512         HILOG_WARN("HandleDisableAbility permission denied.");
513         reply.WriteInt32(RET_ERR_NO_PERMISSION);
514         return NO_ERROR;
515     }
516     std::string name = data.ReadString();
517     RetError result = DisableAbility(name);
518     reply.WriteInt32(result);
519     return NO_ERROR;
520 }
521 
HandleEnableUITestAbility(MessageParcel & data,MessageParcel & reply)522 ErrCode AccessibleAbilityManagerServiceStub::HandleEnableUITestAbility(
523     MessageParcel &data, MessageParcel &reply)
524 {
525     int32_t clientPid = IPCSkeleton::GetCallingPid();
526     HILOG_INFO("EnableUITestAbility called by %{public}d", clientPid);
527     if (!IsSystemApp()) {
528         HILOG_WARN("HandleEnableUITestAbility Permission denied");
529         reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
530         return NO_ERROR;
531     }
532     sptr<IRemoteObject> obj = data.ReadRemoteObject();
533     int32_t result = EnableUITestAbility(obj);
534     if (!reply.WriteInt32(result)) {
535         HILOG_ERROR("WriteBool failed");
536         return TRANSACTION_ERR;
537     }
538     return NO_ERROR;
539 }
540 
HandleGetActiveWindow(MessageParcel & data,MessageParcel & reply)541 ErrCode AccessibleAbilityManagerServiceStub::HandleGetActiveWindow(MessageParcel &data, MessageParcel &reply)
542 {
543     HILOG_DEBUG();
544 
545     int32_t activeWindow = GetActiveWindow();
546     reply.WriteInt32(activeWindow);
547 
548     return NO_ERROR;
549 }
550 
HandleDisableUITestAbility(MessageParcel & data,MessageParcel & reply)551 ErrCode AccessibleAbilityManagerServiceStub::HandleDisableUITestAbility(
552     MessageParcel &data, MessageParcel &reply)
553 {
554     int32_t clientPid = IPCSkeleton::GetCallingPid();
555     HILOG_INFO("DisableUITestAbility called by %{public}d", clientPid);
556     if (!IsSystemApp()) {
557         HILOG_WARN("HandleDisableUITestAbility Permission denied");
558         reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
559         return NO_ERROR;
560     }
561     int32_t result = DisableUITestAbility();
562     if (!reply.WriteInt32(result)) {
563         HILOG_ERROR("WriteBool failed");
564         return TRANSACTION_ERR;
565     }
566     return NO_ERROR;
567 }
568 
HandleSetScreenMagnificationState(MessageParcel & data,MessageParcel & reply)569 ErrCode AccessibleAbilityManagerServiceStub::HandleSetScreenMagnificationState(
570     MessageParcel& data, MessageParcel& reply)
571 {
572     HILOG_DEBUG();
573     if (!CheckPermission(OHOS_PERMISSION_WRITE_ACCESSIBILITY_CONFIG)) {
574         HILOG_WARN("HandleSetScreenMagnificationState permission denied.");
575         reply.WriteInt32(RET_ERR_NO_PERMISSION);
576         return NO_ERROR;
577     }
578     bool state = data.ReadBool();
579 
580     reply.WriteInt32(SetScreenMagnificationState(state));
581 
582     return NO_ERROR;
583 }
584 
HandleSetShortKeyState(MessageParcel & data,MessageParcel & reply)585 ErrCode AccessibleAbilityManagerServiceStub::HandleSetShortKeyState(MessageParcel &data, MessageParcel &reply)
586 {
587     HILOG_DEBUG();
588 
589     if (!IsSystemApp()) {
590         HILOG_WARN("HandleSetShortKeyState Not system app");
591         reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
592         return NO_ERROR;
593     }
594     if (!CheckPermission(OHOS_PERMISSION_WRITE_ACCESSIBILITY_CONFIG)) {
595         HILOG_WARN("HandleSetShortKeyState permission denied.");
596         reply.WriteInt32(RET_ERR_NO_PERMISSION);
597         return NO_ERROR;
598     }
599     bool state = data.ReadBool();
600 
601     reply.WriteInt32(SetShortKeyState(state));
602 
603     return NO_ERROR;
604 }
605 
HandleSetMouseKeyState(MessageParcel & data,MessageParcel & reply)606 ErrCode AccessibleAbilityManagerServiceStub::HandleSetMouseKeyState(MessageParcel &data, MessageParcel &reply)
607 {
608     HILOG_DEBUG();
609 
610     if (!IsSystemApp()) {
611         HILOG_WARN("HandleSetMouseKeyState Not system app");
612         reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
613         return NO_ERROR;
614     }
615     if (!CheckPermission(OHOS_PERMISSION_WRITE_ACCESSIBILITY_CONFIG)) {
616         HILOG_WARN("HandleSetMouseKeyState permission denied.");
617         reply.WriteInt32(RET_ERR_NO_PERMISSION);
618         return NO_ERROR;
619     }
620     bool state = data.ReadBool();
621 
622     reply.WriteInt32(SetMouseKeyState(state));
623 
624     return NO_ERROR;
625 }
626 
HandleSetShortkeyTarget(MessageParcel & data,MessageParcel & reply)627 ErrCode AccessibleAbilityManagerServiceStub::HandleSetShortkeyTarget(MessageParcel &data, MessageParcel &reply)
628 {
629     HILOG_DEBUG();
630 
631     if (!IsSystemApp()) {
632         HILOG_WARN("HandleSetShortkeyTarget Not system app");
633         reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
634         return NO_ERROR;
635     }
636     if (!CheckPermission(OHOS_PERMISSION_WRITE_ACCESSIBILITY_CONFIG)) {
637         HILOG_WARN("HandleSetShortkeyTarget permission denied.");
638         reply.WriteInt32(RET_ERR_NO_PERMISSION);
639         return NO_ERROR;
640     }
641     std::string name = data.ReadString();
642 
643     reply.WriteInt32(SetShortkeyTarget(name));
644 
645     return NO_ERROR;
646 }
647 
HandleSetShortkeyMultiTarget(MessageParcel & data,MessageParcel & reply)648 ErrCode AccessibleAbilityManagerServiceStub::HandleSetShortkeyMultiTarget(MessageParcel &data, MessageParcel &reply)
649 {
650     HILOG_DEBUG();
651 
652     if (!IsSystemApp()) {
653         HILOG_WARN("HandleSetShortkeyMultiTarget Not system app");
654         reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
655         return NO_ERROR;
656     }
657     if (!CheckPermission(OHOS_PERMISSION_WRITE_ACCESSIBILITY_CONFIG)) {
658         HILOG_WARN("HandleSetShortkeyMultiTarget permission denied.");
659         reply.WriteInt32(RET_ERR_NO_PERMISSION);
660         return NO_ERROR;
661     }
662     std::vector<std::string> name;
663     data.ReadStringVector(&name);
664     reply.WriteInt32(SetShortkeyMultiTarget(name));
665 
666     return NO_ERROR;
667 }
668 
HandleSetMouseAutoClick(MessageParcel & data,MessageParcel & reply)669 ErrCode AccessibleAbilityManagerServiceStub::HandleSetMouseAutoClick(MessageParcel &data, MessageParcel &reply)
670 {
671     HILOG_DEBUG();
672 
673     if (!IsSystemApp()) {
674         HILOG_WARN("HandleSetMouseAutoClick Not system app");
675         reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
676         return NO_ERROR;
677     }
678     if (!CheckPermission(OHOS_PERMISSION_WRITE_ACCESSIBILITY_CONFIG)) {
679         HILOG_WARN("HandleSetMouseAutoClick permission denied.");
680         reply.WriteInt32(RET_ERR_NO_PERMISSION);
681         return NO_ERROR;
682     }
683     int32_t time = data.ReadInt32();
684 
685     reply.WriteInt32(SetMouseAutoClick(time));
686 
687     return NO_ERROR;
688 }
689 
HandleSetInvertColorState(MessageParcel & data,MessageParcel & reply)690 ErrCode AccessibleAbilityManagerServiceStub::HandleSetInvertColorState(MessageParcel &data, MessageParcel &reply)
691 {
692     HILOG_DEBUG();
693 
694     if (!IsSystemApp()) {
695         HILOG_WARN("HandleSetInvertColorState Not system app");
696         reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
697         return NO_ERROR;
698     }
699     if (!CheckPermission(OHOS_PERMISSION_WRITE_ACCESSIBILITY_CONFIG)) {
700         HILOG_WARN("HandleSetInvertColorState permission denied.");
701         reply.WriteInt32(RET_ERR_NO_PERMISSION);
702         return NO_ERROR;
703     }
704     bool state = data.ReadBool();
705 
706     reply.WriteInt32(SetInvertColorState(state));
707 
708     return NO_ERROR;
709 }
710 
HandleSetHighContrastTextState(MessageParcel & data,MessageParcel & reply)711 ErrCode AccessibleAbilityManagerServiceStub::HandleSetHighContrastTextState(MessageParcel &data, MessageParcel &reply)
712 {
713     HILOG_DEBUG();
714 
715     if (!IsSystemApp()) {
716         HILOG_WARN("HandleSetHighContrastTextState Not system app");
717         reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
718         return NO_ERROR;
719     }
720     if (!CheckPermission(OHOS_PERMISSION_WRITE_ACCESSIBILITY_CONFIG)) {
721         HILOG_WARN("HandleSetHighContrastTextState permission denied.");
722         reply.WriteInt32(RET_ERR_NO_PERMISSION);
723         return NO_ERROR;
724     }
725     bool state = data.ReadBool();
726 
727     reply.WriteInt32(SetHighContrastTextState(state));
728 
729     return NO_ERROR;
730 }
731 
HandleSetAudioMonoState(MessageParcel & data,MessageParcel & reply)732 ErrCode AccessibleAbilityManagerServiceStub::HandleSetAudioMonoState(MessageParcel &data, MessageParcel &reply)
733 {
734     HILOG_DEBUG();
735     if (!CheckPermission(OHOS_PERMISSION_WRITE_ACCESSIBILITY_CONFIG)) {
736         HILOG_WARN("HandleSetAudioMonoState permission denied.");
737         reply.WriteInt32(RET_ERR_NO_PERMISSION);
738         return NO_ERROR;
739     }
740     bool state = data.ReadBool();
741 
742     reply.WriteInt32(SetAudioMonoState(state));
743 
744     return NO_ERROR;
745 }
746 
747 
HandleSetAnimationOffState(MessageParcel & data,MessageParcel & reply)748 ErrCode AccessibleAbilityManagerServiceStub::HandleSetAnimationOffState(MessageParcel &data, MessageParcel &reply)
749 {
750     HILOG_DEBUG();
751 
752     if (!IsSystemApp()) {
753         HILOG_WARN("HandleSetAnimationOffState Not system app");
754         reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
755         return NO_ERROR;
756     }
757     if (!CheckPermission(OHOS_PERMISSION_WRITE_ACCESSIBILITY_CONFIG)) {
758         HILOG_WARN("HandleSetAnimationOffState permission denied.");
759         reply.WriteInt32(RET_ERR_NO_PERMISSION);
760         return NO_ERROR;
761     }
762     bool state = data.ReadBool();
763 
764     reply.WriteInt32(SetAnimationOffState(state));
765 
766     return NO_ERROR;
767 }
768 
HandleSetDaltonizationState(MessageParcel & data,MessageParcel & reply)769 ErrCode AccessibleAbilityManagerServiceStub::HandleSetDaltonizationState(
770     MessageParcel &data, MessageParcel &reply)
771 {
772     HILOG_DEBUG();
773 
774     if (!IsSystemApp()) {
775         HILOG_WARN("HandleSetDaltonizationState Not system app");
776         reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
777         return NO_ERROR;
778     }
779     if (!CheckPermission(OHOS_PERMISSION_WRITE_ACCESSIBILITY_CONFIG)) {
780         HILOG_WARN("HandleSetDaltonizationState permission denied.");
781         reply.WriteInt32(RET_ERR_NO_PERMISSION);
782         return NO_ERROR;
783     }
784     bool state = data.ReadBool();
785 
786     reply.WriteInt32(SetDaltonizationState(state));
787 
788     return NO_ERROR;
789 }
790 
HandleSetDaltonizationColorFilter(MessageParcel & data,MessageParcel & reply)791 ErrCode AccessibleAbilityManagerServiceStub::HandleSetDaltonizationColorFilter(
792     MessageParcel& data, MessageParcel& reply)
793 {
794     HILOG_DEBUG();
795 
796     if (!IsSystemApp()) {
797         HILOG_WARN("HandleSetDaltonizationColorFilter Not system app");
798         reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
799         return NO_ERROR;
800     }
801     if (!CheckPermission(OHOS_PERMISSION_WRITE_ACCESSIBILITY_CONFIG)) {
802         HILOG_WARN("HandleSetDaltonizationColorFilter permission denied.");
803         reply.WriteInt32(RET_ERR_NO_PERMISSION);
804         return NO_ERROR;
805     }
806     uint32_t filter = data.ReadUint32();
807 
808     reply.WriteInt32(SetDaltonizationColorFilter(filter));
809 
810     return NO_ERROR;
811 }
812 
HandleSetContentTimeout(MessageParcel & data,MessageParcel & reply)813 ErrCode AccessibleAbilityManagerServiceStub::HandleSetContentTimeout(MessageParcel &data, MessageParcel &reply)
814 {
815     HILOG_DEBUG();
816 
817     if (!IsSystemApp()) {
818         HILOG_WARN("HandleSetContentTimeout Not system app");
819         reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
820         return NO_ERROR;
821     }
822     if (!CheckPermission(OHOS_PERMISSION_WRITE_ACCESSIBILITY_CONFIG)) {
823         HILOG_WARN("HandleSetContentTimeout permission denied.");
824         reply.WriteInt32(RET_ERR_NO_PERMISSION);
825         return NO_ERROR;
826     }
827     uint32_t time = data.ReadUint32();
828 
829     reply.WriteInt32(SetContentTimeout(time));
830 
831     return NO_ERROR;
832 }
833 
HandleSetBrightnessDiscount(MessageParcel & data,MessageParcel & reply)834 ErrCode AccessibleAbilityManagerServiceStub::HandleSetBrightnessDiscount(MessageParcel &data, MessageParcel &reply)
835 {
836     HILOG_DEBUG();
837 
838     if (!IsSystemApp()) {
839         HILOG_WARN("HandleSetBrightnessDiscount Not system app");
840         reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
841         return NO_ERROR;
842     }
843     if (!CheckPermission(OHOS_PERMISSION_WRITE_ACCESSIBILITY_CONFIG)) {
844         HILOG_WARN("HandleSetBrightnessDiscount permission denied.");
845         reply.WriteInt32(RET_ERR_NO_PERMISSION);
846         return NO_ERROR;
847     }
848     float discount = data.ReadFloat();
849 
850     reply.WriteInt32(SetBrightnessDiscount(discount));
851 
852     return NO_ERROR;
853 }
854 
HandleSetAudioBalance(MessageParcel & data,MessageParcel & reply)855 ErrCode AccessibleAbilityManagerServiceStub::HandleSetAudioBalance(MessageParcel &data, MessageParcel &reply)
856 {
857     HILOG_DEBUG();
858     if (!CheckPermission(OHOS_PERMISSION_WRITE_ACCESSIBILITY_CONFIG)) {
859         HILOG_WARN("HandleSetAudioBalance permission denied.");
860         reply.WriteInt32(RET_ERR_NO_PERMISSION);
861         return NO_ERROR;
862     }
863     float balance = data.ReadFloat();
864 
865     reply.WriteInt32(SetAudioBalance(balance));
866 
867     return NO_ERROR;
868 }
869 
HandleSetClickResponseTime(MessageParcel & data,MessageParcel & reply)870 ErrCode AccessibleAbilityManagerServiceStub::HandleSetClickResponseTime(MessageParcel &data, MessageParcel &reply)
871 {
872     HILOG_DEBUG();
873     if (!CheckPermission(OHOS_PERMISSION_WRITE_ACCESSIBILITY_CONFIG)) {
874         HILOG_WARN("HandleSetClickResponseTime permission denied.");
875         reply.WriteInt32(RET_ERR_NO_PERMISSION);
876         return NO_ERROR;
877     }
878     uint32_t time = data.ReadUint32();
879 
880     reply.WriteInt32(SetClickResponseTime(time));
881 
882     return NO_ERROR;
883 }
884 
HandleSetIgnoreRepeatClickState(MessageParcel & data,MessageParcel & reply)885 ErrCode AccessibleAbilityManagerServiceStub::HandleSetIgnoreRepeatClickState(MessageParcel &data, MessageParcel &reply)
886 {
887     HILOG_DEBUG();
888     if (!CheckPermission(OHOS_PERMISSION_WRITE_ACCESSIBILITY_CONFIG)) {
889         HILOG_WARN("HandleSetIgnoreRepeatClickState permission denied.");
890         reply.WriteInt32(RET_ERR_NO_PERMISSION);
891         return NO_ERROR;
892     }
893     bool state = data.ReadBool();
894 
895     reply.WriteInt32(SetIgnoreRepeatClickState(state));
896 
897     return NO_ERROR;
898 }
899 
HandleSetIgnoreRepeatClickTime(MessageParcel & data,MessageParcel & reply)900 ErrCode AccessibleAbilityManagerServiceStub::HandleSetIgnoreRepeatClickTime(MessageParcel &data, MessageParcel &reply)
901 {
902     HILOG_DEBUG();
903     if (!CheckPermission(OHOS_PERMISSION_WRITE_ACCESSIBILITY_CONFIG)) {
904         HILOG_WARN("HandleSetIgnoreRepeatClickTime permission denied.");
905         reply.WriteInt32(RET_ERR_NO_PERMISSION);
906         return NO_ERROR;
907     }
908     uint32_t time = data.ReadUint32();
909 
910     reply.WriteInt32(SetIgnoreRepeatClickTime(time));
911 
912     return NO_ERROR;
913 }
914 
HandleGetScreenMagnificationState(MessageParcel & data,MessageParcel & reply)915 ErrCode AccessibleAbilityManagerServiceStub::HandleGetScreenMagnificationState(
916     MessageParcel& data, MessageParcel& reply)
917 {
918     HILOG_DEBUG();
919     bool result = false;
920     RetError ret = GetScreenMagnificationState(result);
921     reply.WriteInt32(ret);
922     if (ret == RET_OK) {
923         reply.WriteBool(result);
924     }
925     return NO_ERROR;
926 }
927 
HandleGetShortKeyState(MessageParcel & data,MessageParcel & reply)928 ErrCode AccessibleAbilityManagerServiceStub::HandleGetShortKeyState(MessageParcel &data, MessageParcel &reply)
929 {
930     HILOG_DEBUG();
931 
932     if (!IsSystemApp()) {
933         HILOG_WARN("Not system app");
934         reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
935         return NO_ERROR;
936     }
937     bool result = false;
938     RetError ret = GetShortKeyState(result);
939     reply.WriteInt32(ret);
940     if (ret == RET_OK) {
941         reply.WriteBool(result);
942     }
943     return NO_ERROR;
944 }
945 
HandleGetMouseKeyState(MessageParcel & data,MessageParcel & reply)946 ErrCode AccessibleAbilityManagerServiceStub::HandleGetMouseKeyState(MessageParcel &data, MessageParcel &reply)
947 {
948     HILOG_DEBUG();
949 
950     if (!IsSystemApp()) {
951         HILOG_WARN("Not system app");
952         reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
953         return NO_ERROR;
954     }
955     bool result = false;
956     RetError ret = GetMouseKeyState(result);
957     reply.WriteInt32(ret);
958     if (ret == RET_OK) {
959         reply.WriteBool(result);
960     }
961     return NO_ERROR;
962 }
963 
HandleGetShortkeyTarget(MessageParcel & data,MessageParcel & reply)964 ErrCode AccessibleAbilityManagerServiceStub::HandleGetShortkeyTarget(MessageParcel &data, MessageParcel &reply)
965 {
966     HILOG_DEBUG();
967 
968     if (!IsSystemApp()) {
969         HILOG_WARN("Not system app");
970         reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
971         return NO_ERROR;
972     }
973     std::string result = "";
974     RetError ret = GetShortkeyTarget(result);
975     reply.WriteInt32(ret);
976     if (ret == RET_OK) {
977         reply.WriteString(result);
978     }
979     return NO_ERROR;
980 }
981 
HandleGetShortkeyMultiTarget(MessageParcel & data,MessageParcel & reply)982 ErrCode AccessibleAbilityManagerServiceStub::HandleGetShortkeyMultiTarget(MessageParcel &data, MessageParcel &reply)
983 {
984     HILOG_DEBUG();
985 
986     if (!IsSystemApp()) {
987         HILOG_WARN("Not system app");
988         reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
989         return NO_ERROR;
990     }
991 
992     std::vector<std::string> result;
993     RetError ret = GetShortkeyMultiTarget(result);
994     reply.WriteInt32(ret);
995     if (ret == RET_OK) {
996         reply.WriteStringVector(result);
997     }
998     return NO_ERROR;
999 }
1000 
HandleGetMouseAutoClick(MessageParcel & data,MessageParcel & reply)1001 ErrCode AccessibleAbilityManagerServiceStub::HandleGetMouseAutoClick(MessageParcel &data, MessageParcel &reply)
1002 {
1003     HILOG_DEBUG();
1004 
1005     if (!IsSystemApp()) {
1006         HILOG_WARN("Not system app");
1007         reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
1008         return NO_ERROR;
1009     }
1010     int32_t result = 0;
1011     RetError ret = GetMouseAutoClick(result);
1012     reply.WriteInt32(ret);
1013     if (ret == RET_OK) {
1014         reply.WriteInt32(result);
1015     }
1016     return NO_ERROR;
1017 }
1018 
HandleGetInvertColorState(MessageParcel & data,MessageParcel & reply)1019 ErrCode AccessibleAbilityManagerServiceStub::HandleGetInvertColorState(MessageParcel &data, MessageParcel &reply)
1020 {
1021     HILOG_DEBUG();
1022 
1023     if (!IsSystemApp()) {
1024         HILOG_WARN("Not system app");
1025         reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
1026         return NO_ERROR;
1027     }
1028     bool result = false;
1029     RetError ret = GetInvertColorState(result);
1030     reply.WriteInt32(ret);
1031     if (ret == RET_OK) {
1032         reply.WriteBool(result);
1033     }
1034     return NO_ERROR;
1035 }
1036 
HandleGetHighContrastTextState(MessageParcel & data,MessageParcel & reply)1037 ErrCode AccessibleAbilityManagerServiceStub::HandleGetHighContrastTextState(MessageParcel &data, MessageParcel &reply)
1038 {
1039     HILOG_DEBUG();
1040 
1041     if (!IsSystemApp()) {
1042         HILOG_WARN("Not system app");
1043         reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
1044         return NO_ERROR;
1045     }
1046     bool result = false;
1047     RetError ret = GetHighContrastTextState(result);
1048     reply.WriteInt32(ret);
1049     if (ret == RET_OK) {
1050         reply.WriteBool(result);
1051     }
1052     return NO_ERROR;
1053 }
1054 
HandleGetAudioMonoState(MessageParcel & data,MessageParcel & reply)1055 ErrCode AccessibleAbilityManagerServiceStub::HandleGetAudioMonoState(MessageParcel &data, MessageParcel &reply)
1056 {
1057     HILOG_DEBUG();
1058     bool result = false;
1059     RetError ret = GetAudioMonoState(result);
1060     reply.WriteInt32(ret);
1061     if (ret == RET_OK) {
1062         reply.WriteBool(result);
1063     }
1064     return NO_ERROR;
1065 }
1066 
HandleGetAnimationOffState(MessageParcel & data,MessageParcel & reply)1067 ErrCode AccessibleAbilityManagerServiceStub::HandleGetAnimationOffState(MessageParcel &data, MessageParcel &reply)
1068 {
1069     HILOG_DEBUG();
1070 
1071     if (!IsSystemApp()) {
1072         HILOG_WARN("Not system app");
1073         reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
1074         return NO_ERROR;
1075     }
1076     bool result = false;
1077     RetError ret = GetAnimationOffState(result);
1078     reply.WriteInt32(ret);
1079     if (ret == RET_OK) {
1080         reply.WriteBool(result);
1081     }
1082     return NO_ERROR;
1083 }
1084 
HandleGetDaltonizationState(MessageParcel & data,MessageParcel & reply)1085 ErrCode AccessibleAbilityManagerServiceStub::HandleGetDaltonizationState(
1086     MessageParcel &data, MessageParcel &reply)
1087 {
1088     HILOG_DEBUG();
1089 
1090     if (!IsSystemApp()) {
1091         HILOG_WARN("Not system app");
1092         reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
1093         return NO_ERROR;
1094     }
1095     bool result = false;
1096     RetError ret = GetDaltonizationState(result);
1097     reply.WriteInt32(ret);
1098     if (ret == RET_OK) {
1099         reply.WriteBool(result);
1100     }
1101     return NO_ERROR;
1102 }
1103 
HandleGetDaltonizationColorFilter(MessageParcel & data,MessageParcel & reply)1104 ErrCode AccessibleAbilityManagerServiceStub::HandleGetDaltonizationColorFilter(
1105     MessageParcel& data, MessageParcel& reply)
1106 {
1107     HILOG_DEBUG();
1108 
1109     if (!IsSystemApp()) {
1110         HILOG_WARN("Not system app");
1111         reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
1112         return NO_ERROR;
1113     }
1114     uint32_t result = 0;
1115     RetError ret = GetDaltonizationColorFilter(result);
1116     reply.WriteInt32(ret);
1117     if (ret == RET_OK) {
1118         reply.WriteUint32(result);
1119     }
1120     return NO_ERROR;
1121 }
1122 
HandleGetContentTimeout(MessageParcel & data,MessageParcel & reply)1123 ErrCode AccessibleAbilityManagerServiceStub::HandleGetContentTimeout(MessageParcel &data, MessageParcel &reply)
1124 {
1125     HILOG_DEBUG();
1126 
1127     if (!IsSystemApp()) {
1128         HILOG_WARN("Not system app");
1129         reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
1130         return NO_ERROR;
1131     }
1132     uint32_t result = 0;
1133     RetError ret = GetContentTimeout(result);
1134     reply.WriteInt32(ret);
1135     if (ret == RET_OK) {
1136         reply.WriteUint32(result);
1137     }
1138     return NO_ERROR;
1139 }
1140 
HandleGetBrightnessDiscount(MessageParcel & data,MessageParcel & reply)1141 ErrCode AccessibleAbilityManagerServiceStub::HandleGetBrightnessDiscount(MessageParcel &data, MessageParcel &reply)
1142 {
1143     HILOG_DEBUG();
1144 
1145     if (!IsSystemApp()) {
1146         HILOG_WARN("Not system app");
1147         reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
1148         return NO_ERROR;
1149     }
1150     float result = 0;
1151     RetError ret = GetBrightnessDiscount(result);
1152     reply.WriteInt32(ret);
1153     if (ret == RET_OK) {
1154         reply.WriteFloat(result);
1155     }
1156     return NO_ERROR;
1157 }
1158 
HandleGetAudioBalance(MessageParcel & data,MessageParcel & reply)1159 ErrCode AccessibleAbilityManagerServiceStub::HandleGetAudioBalance(MessageParcel &data, MessageParcel &reply)
1160 {
1161     HILOG_DEBUG();
1162     float result = 0;
1163     RetError ret = GetAudioBalance(result);
1164     reply.WriteInt32(ret);
1165     if (ret == RET_OK) {
1166         reply.WriteFloat(result);
1167     }
1168     return NO_ERROR;
1169 }
1170 
HandleGetClickResponseTime(MessageParcel & data,MessageParcel & reply)1171 ErrCode AccessibleAbilityManagerServiceStub::HandleGetClickResponseTime(MessageParcel &data, MessageParcel &reply)
1172 {
1173     HILOG_DEBUG();
1174     uint32_t result = 0;
1175     RetError ret = GetClickResponseTime(result);
1176     reply.WriteInt32(ret);
1177     if (ret == RET_OK) {
1178         reply.WriteUint32(result);
1179     }
1180     return NO_ERROR;
1181 }
1182 
HandleGetIgnoreRepeatClickState(MessageParcel & data,MessageParcel & reply)1183 ErrCode AccessibleAbilityManagerServiceStub::HandleGetIgnoreRepeatClickState(MessageParcel &data, MessageParcel &reply)
1184 {
1185     HILOG_DEBUG();
1186     bool result = 0;
1187     RetError ret = GetIgnoreRepeatClickState(result);
1188     reply.WriteInt32(ret);
1189     if (ret == RET_OK) {
1190         reply.WriteBool(result);
1191     }
1192     return NO_ERROR;
1193 }
1194 
HandleGetIgnoreRepeatClickTime(MessageParcel & data,MessageParcel & reply)1195 ErrCode AccessibleAbilityManagerServiceStub::HandleGetIgnoreRepeatClickTime(MessageParcel &data, MessageParcel &reply)
1196 {
1197     HILOG_DEBUG();
1198     uint32_t result = 0;
1199     RetError ret = GetIgnoreRepeatClickTime(result);
1200     reply.WriteInt32(ret);
1201     if (ret == RET_OK) {
1202         reply.WriteUint32(result);
1203     }
1204     return NO_ERROR;
1205 }
1206 
HandleGetAllConfigs(MessageParcel & data,MessageParcel & reply)1207 ErrCode AccessibleAbilityManagerServiceStub::HandleGetAllConfigs(MessageParcel &data, MessageParcel &reply)
1208 {
1209     HILOG_DEBUG();
1210 
1211     if (!IsSystemApp()) {
1212         HILOG_WARN("Not system app");
1213         reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
1214         return NO_ERROR;
1215     }
1216     reply.WriteInt32(RET_OK);
1217 
1218     AccessibilityConfigData configData;
1219     GetAllConfigs(configData);
1220     CaptionPropertyParcel captionParcel(configData.captionProperty_);
1221     reply.WriteBool(configData.highContrastText_);
1222     reply.WriteBool(configData.invertColor_);
1223     reply.WriteBool(configData.animationOff_);
1224     reply.WriteBool(configData.audioMono_);
1225     reply.WriteBool(configData.mouseKey_);
1226     reply.WriteBool(configData.captionState_);
1227     reply.WriteBool(configData.screenMagnifier_);
1228     reply.WriteBool(configData.shortkey_);
1229     reply.WriteInt32(configData.mouseAutoClick_);
1230     reply.WriteBool(configData.daltonizationState_);
1231     reply.WriteUint32(configData.daltonizationColorFilter_);
1232     reply.WriteUint32(configData.contentTimeout_);
1233     reply.WriteFloat(configData.brightnessDiscount_);
1234     reply.WriteFloat(configData.audioBalance_);
1235     reply.WriteString(configData.shortkeyTarget_);
1236     reply.WriteParcelable(&captionParcel);
1237     reply.WriteStringVector(configData.shortkeyMultiTarget_);
1238     return NO_ERROR;
1239 }
1240 
HandleRegisterEnableAbilityListsObserver(MessageParcel & data,MessageParcel & reply)1241 ErrCode AccessibleAbilityManagerServiceStub::HandleRegisterEnableAbilityListsObserver(
1242     MessageParcel &data, MessageParcel &reply)
1243 {
1244     HILOG_DEBUG();
1245     sptr<IRemoteObject> obj = data.ReadRemoteObject();
1246     sptr<IAccessibilityEnableAbilityListsObserver> observer =
1247         iface_cast<IAccessibilityEnableAbilityListsObserver>(obj);
1248     RegisterEnableAbilityListsObserver(observer);
1249 
1250     return NO_ERROR;
1251 }
1252 
HandleRegisterConfigCallback(MessageParcel & data,MessageParcel & reply)1253 ErrCode AccessibleAbilityManagerServiceStub::HandleRegisterConfigCallback(
1254     MessageParcel &data, MessageParcel &reply)
1255 {
1256     HILOG_DEBUG();
1257 
1258     sptr<IRemoteObject> obj = data.ReadRemoteObject();
1259     if (obj == nullptr) {
1260         HILOG_ERROR("obj is nullptr.");
1261         return ERR_INVALID_VALUE;
1262     }
1263 
1264     sptr<IAccessibleAbilityManagerConfigObserver> config = iface_cast<IAccessibleAbilityManagerConfigObserver>(obj);
1265     if (config == nullptr) {
1266         HILOG_ERROR("config is nullptr");
1267         return ERR_INVALID_VALUE;
1268     }
1269     uint64_t result = RegisterConfigObserver(config);
1270     reply.WriteUint64(result);
1271 
1272     return NO_ERROR;
1273 }
1274 
HandleGetWindowAndElementId(MessageParcel & data,MessageParcel & reply)1275 ErrCode AccessibleAbilityManagerServiceStub::HandleGetWindowAndElementId(MessageParcel &data,
1276     MessageParcel &reply)
1277 {
1278     HILOG_DEBUG();
1279     int32_t windowId = data.ReadInt32();
1280     int64_t elementId = data.ReadInt64();
1281     GetRealWindowAndElementId(windowId, elementId);
1282     if (!reply.WriteInt32(windowId)) {
1283         HILOG_ERROR("write windowId fail");
1284     }
1285 
1286     if (!reply.WriteInt64(elementId)) {
1287         HILOG_ERROR("write elementId fail");
1288     }
1289 
1290     return NO_ERROR;
1291 }
1292 
HandleGetSceneBoardInnerWinId(MessageParcel & data,MessageParcel & reply)1293 ErrCode AccessibleAbilityManagerServiceStub::HandleGetSceneBoardInnerWinId(MessageParcel &data,
1294     MessageParcel &reply)
1295 {
1296     HILOG_DEBUG();
1297     int32_t windowId = data.ReadInt32();
1298     int64_t elementId = data.ReadInt64();
1299     int32_t innerWid = -1;
1300     GetSceneBoardInnerWinId(windowId, elementId, innerWid);
1301     if (!reply.WriteInt32(innerWid)) {
1302         HILOG_ERROR("write windowId fail");
1303     }
1304     return NO_ERROR;
1305 }
1306 
HandleGetFocusedWindowId(MessageParcel & data,MessageParcel & reply)1307 ErrCode AccessibleAbilityManagerServiceStub::HandleGetFocusedWindowId(MessageParcel &data,
1308     MessageParcel &reply)
1309 {
1310     HILOG_DEBUG();
1311     int32_t focusedWindowId = -1;
1312     GetFocusedWindowId(focusedWindowId);
1313     if (reply.WriteInt32(focusedWindowId)) {
1314         HILOG_ERROR("write windowId fail");
1315     }
1316     return NO_ERROR;
1317 }
1318 
HandleRemoveRequestId(MessageParcel & data,MessageParcel & reply)1319 ErrCode AccessibleAbilityManagerServiceStub::HandleRemoveRequestId(MessageParcel &data,
1320     MessageParcel &reply)
1321 {
1322     HILOG_DEBUG();
1323     int32_t requestId = data.ReadInt32();
1324     RemoveRequestId(requestId);
1325     return NO_ERROR;
1326 }
1327 
HandleGetRootParentId(MessageParcel & data,MessageParcel & reply)1328 ErrCode AccessibleAbilityManagerServiceStub::HandleGetRootParentId(MessageParcel &data,
1329     MessageParcel &reply)
1330 {
1331     HILOG_DEBUG();
1332     int32_t windowId = data.ReadInt32();
1333     int32_t treeId = data.ReadInt32();
1334     int64_t elementId = GetRootParentId(windowId, treeId);
1335     reply.WriteInt64(elementId);
1336     return NO_ERROR;
1337 }
1338 
HandleGetAllTreeId(MessageParcel & data,MessageParcel & reply)1339 ErrCode AccessibleAbilityManagerServiceStub::HandleGetAllTreeId(MessageParcel &data,
1340     MessageParcel &reply)
1341 {
1342     HILOG_DEBUG();
1343     int32_t windowId = data.ReadInt32();
1344     std::vector<int32_t> treeIds {};
1345 
1346     RetError result = GetAllTreeId(windowId, treeIds);
1347 
1348     reply.WriteInt32(static_cast<int32_t>(result));
1349     int32_t treeIdSize = static_cast<int32_t>(treeIds.size());
1350     reply.WriteInt32(treeIdSize);
1351     for (auto &treeId : treeIds) {
1352         if (!reply.WriteInt32(treeId)) {
1353             HILOG_ERROR("WriteInt32 treeId failed");
1354             return TRANSACTION_ERR;
1355         }
1356     }
1357 
1358     return NO_ERROR;
1359 }
1360 } // namespace Accessibility
1361 } // namespace OHOS
1362