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