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