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