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 namespace OHOS {
27 namespace Accessibility {
28 using namespace Security::AccessToken;
29
AddSetConfigHandles()30 void AccessibleAbilityManagerServiceStub::AddSetConfigHandles()
31 {
32 memberFuncMap_[static_cast<uint32_t>(AccessibilityInterfaceCode::SET_SCREENMAGNIFIER_STATE)] =
33 &AccessibleAbilityManagerServiceStub::HandleSetScreenMagnificationState;
34 memberFuncMap_[static_cast<uint32_t>(AccessibilityInterfaceCode::SET_SHORTKEY_STATE)] =
35 &AccessibleAbilityManagerServiceStub::HandleSetShortKeyState;
36 memberFuncMap_[static_cast<uint32_t>(AccessibilityInterfaceCode::SET_MOUSEKEY_STATE)] =
37 &AccessibleAbilityManagerServiceStub::HandleSetMouseKeyState;
38 memberFuncMap_[static_cast<uint32_t>(AccessibilityInterfaceCode::SET_SHORTKEY_TARGET)] =
39 &AccessibleAbilityManagerServiceStub::HandleSetShortkeyTarget;
40 memberFuncMap_[static_cast<uint32_t>(AccessibilityInterfaceCode::SET_MOUSEKEY_AUTOCLICK)] =
41 &AccessibleAbilityManagerServiceStub::HandleSetMouseAutoClick;
42 memberFuncMap_[static_cast<uint32_t>(AccessibilityInterfaceCode::SET_INVERTCOLOR_STATE)] =
43 &AccessibleAbilityManagerServiceStub::HandleSetInvertColorState;
44 memberFuncMap_[static_cast<uint32_t>(AccessibilityInterfaceCode::SET_HIGHCONTRASTTEXT_STATE)] =
45 &AccessibleAbilityManagerServiceStub::HandleSetHighContrastTextState;
46 memberFuncMap_[static_cast<uint32_t>(AccessibilityInterfaceCode::SET_AUDIOMONO_STATE)] =
47 &AccessibleAbilityManagerServiceStub::HandleSetAudioMonoState;
48 memberFuncMap_[static_cast<uint32_t>(AccessibilityInterfaceCode::SET_ANIMATIONOFF_STATE)] =
49 &AccessibleAbilityManagerServiceStub::HandleSetAnimationOffState;
50 memberFuncMap_[static_cast<uint32_t>(AccessibilityInterfaceCode::SET_DALTONIZATION_COLORFILTER)] =
51 &AccessibleAbilityManagerServiceStub::HandleSetDaltonizationColorFilter;
52 memberFuncMap_[static_cast<uint32_t>(AccessibilityInterfaceCode::SET_CONTENT_TIMEOUT)] =
53 &AccessibleAbilityManagerServiceStub::HandleSetContentTimeout;
54 memberFuncMap_[static_cast<uint32_t>(AccessibilityInterfaceCode::SET_BRIGHTNESS_DISCOUNT)] =
55 &AccessibleAbilityManagerServiceStub::HandleSetBrightnessDiscount;
56 memberFuncMap_[static_cast<uint32_t>(AccessibilityInterfaceCode::SET_AUDIO_BALANCE)] =
57 &AccessibleAbilityManagerServiceStub::HandleSetAudioBalance;
58 memberFuncMap_[static_cast<uint32_t>(AccessibilityInterfaceCode::SET_CAPTION_PROPERTY)] =
59 &AccessibleAbilityManagerServiceStub::HandleSetCaptionProperty;
60 memberFuncMap_[static_cast<uint32_t>(AccessibilityInterfaceCode::SET_CAPTION_STATE)] =
61 &AccessibleAbilityManagerServiceStub::HandleSetCaptionState;
62 }
63
AddGetConfigHandles()64 void AccessibleAbilityManagerServiceStub::AddGetConfigHandles()
65 {
66 memberFuncMap_[static_cast<uint32_t>(AccessibilityInterfaceCode::GET_SCREENMAGNIFIER_STATE)] =
67 &AccessibleAbilityManagerServiceStub::HandleGetScreenMagnificationState;
68 memberFuncMap_[static_cast<uint32_t>(AccessibilityInterfaceCode::GET_SHORTKEY_STATE)] =
69 &AccessibleAbilityManagerServiceStub::HandleGetShortKeyState;
70 memberFuncMap_[static_cast<uint32_t>(AccessibilityInterfaceCode::GET_MOUSEKEY_STATE)] =
71 &AccessibleAbilityManagerServiceStub::HandleGetMouseKeyState;
72 memberFuncMap_[static_cast<uint32_t>(AccessibilityInterfaceCode::GET_SHORTKEY_TARGET)] =
73 &AccessibleAbilityManagerServiceStub::HandleGetShortkeyTarget;
74 memberFuncMap_[static_cast<uint32_t>(AccessibilityInterfaceCode::GET_MOUSEKEY_AUTOCLICK)] =
75 &AccessibleAbilityManagerServiceStub::HandleGetMouseAutoClick;
76 memberFuncMap_[static_cast<uint32_t>(AccessibilityInterfaceCode::GET_INVERTCOLOR_STATE)] =
77 &AccessibleAbilityManagerServiceStub::HandleGetInvertColorState;
78 memberFuncMap_[static_cast<uint32_t>(AccessibilityInterfaceCode::GET_HIGHCONTRASTTEXT_STATE)] =
79 &AccessibleAbilityManagerServiceStub::HandleGetHighContrastTextState;
80 memberFuncMap_[static_cast<uint32_t>(AccessibilityInterfaceCode::GET_AUDIOMONO_STATE)] =
81 &AccessibleAbilityManagerServiceStub::HandleGetAudioMonoState;
82 memberFuncMap_[static_cast<uint32_t>(AccessibilityInterfaceCode::GET_ANIMATIONOFF_STATE)] =
83 &AccessibleAbilityManagerServiceStub::HandleGetAnimationOffState;
84 memberFuncMap_[static_cast<uint32_t>(AccessibilityInterfaceCode::GET_DALTONIZATION_COLORFILTER)] =
85 &AccessibleAbilityManagerServiceStub::HandleGetDaltonizationColorFilter;
86 memberFuncMap_[static_cast<uint32_t>(AccessibilityInterfaceCode::GET_CONTENT_TIMEOUT)] =
87 &AccessibleAbilityManagerServiceStub::HandleGetContentTimeout;
88 memberFuncMap_[static_cast<uint32_t>(AccessibilityInterfaceCode::GET_BRIGHTNESS_DISCOUNT)] =
89 &AccessibleAbilityManagerServiceStub::HandleGetBrightnessDiscount;
90 memberFuncMap_[static_cast<uint32_t>(AccessibilityInterfaceCode::GET_AUDIO_BALANCE)] =
91 &AccessibleAbilityManagerServiceStub::HandleGetAudioBalance;
92 memberFuncMap_[static_cast<uint32_t>(AccessibilityInterfaceCode::GET_ALL_CONFIGS)] =
93 &AccessibleAbilityManagerServiceStub::HandleGetAllConfigs;
94 memberFuncMap_[static_cast<uint32_t>(AccessibilityInterfaceCode::REGISTER_CONFIG_CALLBACK)] =
95 &AccessibleAbilityManagerServiceStub::HandleRegisterConfigCallback;
96 memberFuncMap_[static_cast<uint32_t>(AccessibilityInterfaceCode::GET_CAPTION_PROPERTY)] =
97 &AccessibleAbilityManagerServiceStub::HandleGetCaptionProperty;
98 memberFuncMap_[static_cast<uint32_t>(AccessibilityInterfaceCode::GET_CAPTION_STATE)] =
99 &AccessibleAbilityManagerServiceStub::HandleGetCaptionState;
100 }
101
AccessibleAbilityManagerServiceStub()102 AccessibleAbilityManagerServiceStub::AccessibleAbilityManagerServiceStub()
103 {
104 HILOG_DEBUG();
105
106 memberFuncMap_[static_cast<uint32_t>(AccessibilityInterfaceCode::SEND_EVENT)] =
107 &AccessibleAbilityManagerServiceStub::HandleSendEvent;
108 memberFuncMap_[static_cast<uint32_t>(AccessibilityInterfaceCode::REGISTER_STATE_CALLBACK)] =
109 &AccessibleAbilityManagerServiceStub::HandleRegisterStateCallback;
110 memberFuncMap_[static_cast<uint32_t>(AccessibilityInterfaceCode::GET_ABILITYLIST)] =
111 &AccessibleAbilityManagerServiceStub::HandleGetAbilityList;
112 memberFuncMap_[static_cast<uint32_t>(
113 AccessibilityInterfaceCode::REGISTER_INTERACTION_CONNECTION)] =
114 &AccessibleAbilityManagerServiceStub::HandleRegisterAccessibilityElementOperator;
115 memberFuncMap_[static_cast<uint32_t>(
116 AccessibilityInterfaceCode::DEREGISTER_INTERACTION_CONNECTION)] =
117 &AccessibleAbilityManagerServiceStub::HandleDeregisterAccessibilityElementOperator;
118
119 memberFuncMap_[static_cast<uint32_t>(AccessibilityInterfaceCode::GET_ENABLED)] =
120 &AccessibleAbilityManagerServiceStub::HandleGetEnabled;
121 memberFuncMap_[static_cast<uint32_t>(AccessibilityInterfaceCode::GET_TOUCH_GUIDE_STATE)] =
122 &AccessibleAbilityManagerServiceStub::HandleGetTouchGuideState;
123 memberFuncMap_[static_cast<uint32_t>(AccessibilityInterfaceCode::GET_GESTURE_STATE)] =
124 &AccessibleAbilityManagerServiceStub::HandleGetGestureState;
125 memberFuncMap_[static_cast<uint32_t>(
126 AccessibilityInterfaceCode::GET_KEY_EVENT_OBSERVE_STATE)] =
127 &AccessibleAbilityManagerServiceStub::HandleGetKeyEventObserverState;
128 memberFuncMap_[static_cast<uint32_t>(AccessibilityInterfaceCode::ENABLE_ABILITIES)] =
129 &AccessibleAbilityManagerServiceStub::HandleEnableAbility;
130 memberFuncMap_[static_cast<uint32_t>(AccessibilityInterfaceCode::GET_ENABLED_OBJECT)] =
131 &AccessibleAbilityManagerServiceStub::HandleGetEnabledAbilities;
132 memberFuncMap_[static_cast<uint32_t>(AccessibilityInterfaceCode::DISABLE_ABILITIES)] =
133 &AccessibleAbilityManagerServiceStub::HandleDisableAbility;
134 memberFuncMap_[static_cast<uint32_t>(
135 AccessibilityInterfaceCode::REGISTER_CAPTION_PROPERTY_CALLBACK)] =
136 &AccessibleAbilityManagerServiceStub::HandleRegisterCaptionPropertyCallback;
137 memberFuncMap_[static_cast<uint32_t>(
138 AccessibilityInterfaceCode::ENABLE_UI_TEST_ABILITY)] =
139 &AccessibleAbilityManagerServiceStub::HandleEnableUITestAbility;
140 memberFuncMap_[static_cast<uint32_t>(
141 AccessibilityInterfaceCode::DISABLE_UI_TEST_ABILITY)] =
142 &AccessibleAbilityManagerServiceStub::HandleDisableUITestAbility;
143 memberFuncMap_[static_cast<uint32_t>(
144 AccessibilityInterfaceCode::GET_ACTIVE_WINDOW)] =
145 &AccessibleAbilityManagerServiceStub::HandleGetActiveWindow;
146 memberFuncMap_[static_cast<uint32_t>(
147 AccessibilityInterfaceCode::REGISTER_ENABLE_ABILITY_LISTS_OBSERVER)] =
148 &AccessibleAbilityManagerServiceStub::HandleRegisterEnableAbilityListsObserver;
149
150 AddSetConfigHandles();
151 AddGetConfigHandles();
152 }
153
~AccessibleAbilityManagerServiceStub()154 AccessibleAbilityManagerServiceStub::~AccessibleAbilityManagerServiceStub()
155 {
156 HILOG_DEBUG("start.");
157 memberFuncMap_.clear();
158 }
159
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)160 int AccessibleAbilityManagerServiceStub::OnRemoteRequest(
161 uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
162 {
163 HILOG_DEBUG("AccessibleAbilityManagerServiceClientStub::OnRemoteRequest, cmd = %{public}u, flags= %{public}d",
164 code, option.GetFlags());
165 std::u16string descriptor = AccessibleAbilityManagerServiceStub::GetDescriptor();
166 std::u16string remoteDescriptor = data.ReadInterfaceToken();
167 if (descriptor != remoteDescriptor) {
168 HILOG_ERROR("AccessibleAbilityManagerServiceClientStub::OnRemoteRequest,"
169 "local descriptor is not equal to remote");
170 return ERR_INVALID_STATE;
171 }
172
173 auto memFunc = memberFuncMap_.find(code);
174 if (memFunc != memberFuncMap_.end()) {
175 auto func = memFunc->second;
176 if (func != nullptr) {
177 return (this->*func)(data, reply);
178 }
179 }
180 HILOG_WARN("AccessibleAbilityManagerServiceStub::OnRemoteRequest, default case, need check.");
181 return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
182 }
183
CheckPermission(const std::string & permission) const184 bool AccessibleAbilityManagerServiceStub::CheckPermission(const std::string &permission) const
185 {
186 HILOG_DEBUG();
187
188 uint32_t callerToken = IPCSkeleton::GetCallingTokenID();
189 int result = TypePermissionState::PERMISSION_GRANTED;
190 ATokenTypeEnum tokenType = AccessTokenKit::GetTokenTypeFlag(callerToken);
191 if (tokenType == TOKEN_INVALID) {
192 HILOG_WARN("AccessToken type:%{private}d, permission:%{private}d denied!", tokenType, callerToken);
193 return false;
194 } else {
195 result = AccessTokenKit::VerifyAccessToken(callerToken, permission);
196 }
197 if (result == TypePermissionState::PERMISSION_DENIED) {
198 HILOG_WARN("AccessTokenID:%{private}u, permission:%{private}s denied!", callerToken, permission.c_str());
199 return false;
200 }
201 HILOG_DEBUG("tokenType %{private}d dAccessTokenID:%{private}u, permission:%{private}s matched!",
202 tokenType, callerToken, permission.c_str());
203 return true;
204 }
205
IsSystemApp() const206 bool AccessibleAbilityManagerServiceStub::IsSystemApp() const
207 {
208 HILOG_DEBUG();
209
210 AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID();
211 ATokenTypeEnum tokenType = AccessTokenKit::GetTokenTypeFlag(callerToken);
212 if (tokenType != TOKEN_HAP) {
213 HILOG_INFO("Caller is not a application.");
214 return true;
215 }
216 uint64_t accessTokenId = IPCSkeleton::GetCallingFullTokenID();
217 bool isSystemApplication = TokenIdKit::IsSystemAppByFullTokenID(accessTokenId);
218 return isSystemApplication;
219 }
220
HandleSendEvent(MessageParcel & data,MessageParcel & reply)221 ErrCode AccessibleAbilityManagerServiceStub::HandleSendEvent(MessageParcel &data, MessageParcel &reply)
222 {
223 HILOG_DEBUG();
224
225 sptr<AccessibilityEventInfoParcel> uiEvent = data.ReadStrongParcelable<AccessibilityEventInfoParcel>();
226 if (!uiEvent) {
227 HILOG_DEBUG("ReadStrongParcelable<AbilityInfo> failed");
228 return TRANSACTION_ERR;
229 }
230 SendEvent(*uiEvent);
231
232 return NO_ERROR;
233 }
234
HandleRegisterStateCallback(MessageParcel & data,MessageParcel & reply)235 ErrCode AccessibleAbilityManagerServiceStub::HandleRegisterStateCallback(
236 MessageParcel &data, MessageParcel &reply)
237 {
238 HILOG_DEBUG();
239
240 sptr<IRemoteObject> obj = data.ReadRemoteObject();
241 sptr<IAccessibleAbilityManagerStateObserver> client = iface_cast<IAccessibleAbilityManagerStateObserver>(obj);
242 uint64_t result = RegisterStateObserver(client);
243 reply.WriteUint64(result);
244
245 return NO_ERROR;
246 }
247
HandleGetAbilityList(MessageParcel & data,MessageParcel & reply)248 ErrCode AccessibleAbilityManagerServiceStub::HandleGetAbilityList(MessageParcel &data, MessageParcel &reply)
249 {
250 HILOG_DEBUG();
251
252 uint32_t abilityTypes = data.ReadUint32();
253 int32_t stateType = data.ReadInt32();
254 std::vector<AccessibilityAbilityInfo> abilityInfos {};
255 RetError result = GetAbilityList(abilityTypes, stateType, abilityInfos);
256
257 int32_t abilityInfoSize = static_cast<int32_t>(abilityInfos.size());
258 reply.WriteInt32(abilityInfoSize);
259 for (auto &abilityInfo : abilityInfos) {
260 sptr<AccessibilityAbilityInfoParcel> info = new(std::nothrow) AccessibilityAbilityInfoParcel(abilityInfo);
261 if (!info) {
262 HILOG_ERROR("Failed to create info.");
263 return ERR_NULL_OBJECT;
264 }
265 if (!reply.WriteStrongParcelable(info)) {
266 HILOG_ERROR("WriteStrongParcelable<AccessibilityAbilityInfoParcel> failed");
267 return TRANSACTION_ERR;
268 }
269 }
270 reply.WriteInt32(static_cast<int32_t>(result));
271 return NO_ERROR;
272 }
273
HandleRegisterAccessibilityElementOperator(MessageParcel & data,MessageParcel & reply)274 ErrCode AccessibleAbilityManagerServiceStub::HandleRegisterAccessibilityElementOperator(
275 MessageParcel &data, MessageParcel &reply)
276 {
277 HILOG_DEBUG();
278
279 int32_t windowId = data.ReadInt32();
280 sptr<IRemoteObject> obj = data.ReadRemoteObject();
281 sptr<IAccessibilityElementOperator> operation = iface_cast<IAccessibilityElementOperator>(obj);
282 RegisterElementOperator(windowId, operation);
283
284 return NO_ERROR;
285 }
286
HandleDeregisterAccessibilityElementOperator(MessageParcel & data,MessageParcel & reply)287 ErrCode AccessibleAbilityManagerServiceStub::HandleDeregisterAccessibilityElementOperator(
288 MessageParcel &data, MessageParcel &reply)
289 {
290 HILOG_DEBUG();
291
292 int32_t windowId = data.ReadInt32();
293 DeregisterElementOperator(windowId);
294
295 return NO_ERROR;
296 }
297
HandleGetCaptionProperty(MessageParcel & data,MessageParcel & reply)298 ErrCode AccessibleAbilityManagerServiceStub::HandleGetCaptionProperty(MessageParcel &data, MessageParcel &reply)
299 {
300 HILOG_DEBUG();
301
302 if (!IsSystemApp()) {
303 HILOG_WARN("Not system app");
304 reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
305 return NO_ERROR;
306 }
307 AccessibilityConfig::CaptionProperty caption = {};
308 RetError ret = GetCaptionProperty(caption);
309 reply.WriteInt32(ret);
310 if (ret == RET_OK) {
311 CaptionPropertyParcel captionParcel(caption);
312 reply.WriteParcelable(&captionParcel);
313 }
314
315 return NO_ERROR;
316 }
317
HandleSetCaptionProperty(MessageParcel & data,MessageParcel & reply)318 ErrCode AccessibleAbilityManagerServiceStub::HandleSetCaptionProperty(MessageParcel &data, MessageParcel &reply)
319 {
320 HILOG_DEBUG();
321
322 if (!IsSystemApp()) {
323 HILOG_WARN("HandleSetCaptionProperty Not system app");
324 reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
325 return NO_ERROR;
326 }
327 if (!CheckPermission(OHOS_PERMISSION_WRITE_ACCESSIBILITY_CONFIG)) {
328 HILOG_WARN("HandleSetCaptionProperty Permission denied!");
329 reply.WriteInt32(RET_ERR_NO_PERMISSION);
330 return NO_ERROR;
331 }
332 sptr<CaptionPropertyParcel> caption = data.ReadStrongParcelable<CaptionPropertyParcel>();
333 if (!caption) {
334 HILOG_ERROR("ReadStrongParcelable<CaptionProperty> failed");
335 reply.WriteInt32(RET_ERR_IPC_FAILED);
336 return TRANSACTION_ERR;
337 }
338 reply.WriteInt32(SetCaptionProperty(*caption));
339
340 return NO_ERROR;
341 }
342
HandleSetCaptionState(MessageParcel & data,MessageParcel & reply)343 ErrCode AccessibleAbilityManagerServiceStub::HandleSetCaptionState(MessageParcel &data, MessageParcel &reply)
344 {
345 HILOG_DEBUG();
346
347 if (!IsSystemApp()) {
348 HILOG_WARN("HandleSetCaptionState Not system app");
349 reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
350 return NO_ERROR;
351 }
352 if (!CheckPermission(OHOS_PERMISSION_WRITE_ACCESSIBILITY_CONFIG)) {
353 HILOG_WARN("HandleSetCaptionState Permission denied!");
354 reply.WriteInt32(RET_ERR_NO_PERMISSION);
355 return NO_ERROR;
356 }
357 bool state = data.ReadBool();
358 reply.WriteInt32(SetCaptionState(state));
359
360 return NO_ERROR;
361 }
362
HandleRegisterCaptionPropertyCallback(MessageParcel & data,MessageParcel & reply)363 ErrCode AccessibleAbilityManagerServiceStub::HandleRegisterCaptionPropertyCallback(
364 MessageParcel &data, MessageParcel &reply)
365 {
366 HILOG_DEBUG();
367
368 sptr<IRemoteObject> remote = data.ReadRemoteObject();
369 sptr<IAccessibleAbilityManagerCaptionObserver> observer =
370 iface_cast<IAccessibleAbilityManagerCaptionObserver>(remote);
371 uint64_t result = RegisterCaptionObserver(observer);
372 reply.WriteUint64(result);
373
374 return NO_ERROR;
375 }
376
HandleGetEnabled(MessageParcel & data,MessageParcel & reply)377 ErrCode AccessibleAbilityManagerServiceStub::HandleGetEnabled(MessageParcel &data, MessageParcel &reply)
378 {
379 HILOG_DEBUG();
380
381 bool result = GetEnabledState();
382 reply.WriteBool(result);
383
384 return NO_ERROR;
385 }
386
HandleGetCaptionState(MessageParcel & data,MessageParcel & reply)387 ErrCode AccessibleAbilityManagerServiceStub::HandleGetCaptionState(MessageParcel &data, MessageParcel &reply)
388 {
389 HILOG_DEBUG();
390
391 if (!IsSystemApp()) {
392 HILOG_WARN("Not system app");
393 reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
394 return NO_ERROR;
395 }
396 bool result = false;
397 RetError ret = GetCaptionState(result);
398 reply.WriteInt32(ret);
399 if (ret == RET_OK) {
400 reply.WriteBool(result);
401 }
402 return NO_ERROR;
403 }
404
HandleGetTouchGuideState(MessageParcel & data,MessageParcel & reply)405 ErrCode AccessibleAbilityManagerServiceStub::HandleGetTouchGuideState(MessageParcel &data, MessageParcel &reply)
406 {
407 HILOG_DEBUG();
408
409 bool result = GetTouchGuideState();
410 reply.WriteBool(result);
411 return NO_ERROR;
412 }
413
HandleGetGestureState(MessageParcel & data,MessageParcel & reply)414 ErrCode AccessibleAbilityManagerServiceStub::HandleGetGestureState(MessageParcel &data, MessageParcel &reply)
415 {
416 HILOG_DEBUG();
417
418 bool result = GetGestureState();
419 reply.WriteBool(result);
420 return NO_ERROR;
421 }
422
HandleGetKeyEventObserverState(MessageParcel & data,MessageParcel & reply)423 ErrCode AccessibleAbilityManagerServiceStub::HandleGetKeyEventObserverState(
424 MessageParcel &data, MessageParcel &reply)
425 {
426 HILOG_DEBUG();
427
428 bool result = GetKeyEventObserverState();
429 reply.WriteBool(result);
430
431 return NO_ERROR;
432 }
433
HandleEnableAbility(MessageParcel & data,MessageParcel & reply)434 ErrCode AccessibleAbilityManagerServiceStub::HandleEnableAbility(MessageParcel &data, MessageParcel &reply)
435 {
436 HILOG_DEBUG();
437
438 if (!IsSystemApp()) {
439 HILOG_WARN("HandleEnableAbility Not system app");
440 reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
441 return NO_ERROR;
442 }
443 if (!CheckPermission(OHOS_PERMISSION_WRITE_ACCESSIBILITY_CONFIG)) {
444 HILOG_WARN("HandleEnableAbility Permission denied!");
445 reply.WriteInt32(RET_ERR_NO_PERMISSION);
446 return NO_ERROR;
447 }
448 std::string name = data.ReadString();
449 uint32_t capabilities = data.ReadUint32();
450 RetError result = EnableAbility(name, capabilities);
451 reply.WriteInt32(result);
452 return NO_ERROR;
453 }
454
HandleGetEnabledAbilities(MessageParcel & data,MessageParcel & reply)455 ErrCode AccessibleAbilityManagerServiceStub::HandleGetEnabledAbilities(MessageParcel &data, MessageParcel &reply)
456 {
457 HILOG_DEBUG();
458
459 std::vector<std::string> enabledAbilities;
460 RetError result = GetEnabledAbilities(enabledAbilities);
461 reply.WriteInt32(enabledAbilities.size());
462 for (auto &ability : enabledAbilities) {
463 if (!reply.WriteString(ability)) {
464 HILOG_ERROR("ability write error: %{public}s, ", ability.c_str());
465 return TRANSACTION_ERR;
466 }
467 }
468 reply.WriteInt32(result);
469 return NO_ERROR;
470 }
471
HandleDisableAbility(MessageParcel & data,MessageParcel & reply)472 ErrCode AccessibleAbilityManagerServiceStub::HandleDisableAbility(MessageParcel &data, MessageParcel &reply)
473 {
474 HILOG_DEBUG();
475
476 if (!IsSystemApp()) {
477 HILOG_WARN("HandleDisableAbility Not system app");
478 reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
479 return NO_ERROR;
480 }
481 if (!CheckPermission(OHOS_PERMISSION_WRITE_ACCESSIBILITY_CONFIG)) {
482 HILOG_WARN("HandleDisableAbility Permission denied!");
483 reply.WriteInt32(RET_ERR_NO_PERMISSION);
484 return NO_ERROR;
485 }
486 std::string name = data.ReadString();
487 RetError result = DisableAbility(name);
488 reply.WriteInt32(result);
489 return NO_ERROR;
490 }
491
HandleEnableUITestAbility(MessageParcel & data,MessageParcel & reply)492 ErrCode AccessibleAbilityManagerServiceStub::HandleEnableUITestAbility(
493 MessageParcel &data, MessageParcel &reply)
494 {
495 HILOG_DEBUG();
496 sptr<IRemoteObject> obj = data.ReadRemoteObject();
497 int32_t result = EnableUITestAbility(obj);
498 if (!reply.WriteInt32(result)) {
499 HILOG_ERROR("WriteBool failed");
500 return TRANSACTION_ERR;
501 }
502 return NO_ERROR;
503 }
504
HandleGetActiveWindow(MessageParcel & data,MessageParcel & reply)505 ErrCode AccessibleAbilityManagerServiceStub::HandleGetActiveWindow(MessageParcel &data, MessageParcel &reply)
506 {
507 HILOG_DEBUG();
508
509 int32_t activeWindow = GetActiveWindow();
510 reply.WriteInt32(activeWindow);
511
512 return NO_ERROR;
513 }
514
HandleDisableUITestAbility(MessageParcel & data,MessageParcel & reply)515 ErrCode AccessibleAbilityManagerServiceStub::HandleDisableUITestAbility(
516 MessageParcel &data, MessageParcel &reply)
517 {
518 HILOG_DEBUG();
519 int32_t result = DisableUITestAbility();
520 if (!reply.WriteInt32(result)) {
521 HILOG_ERROR("WriteBool failed");
522 return TRANSACTION_ERR;
523 }
524 return NO_ERROR;
525 }
526
HandleSetScreenMagnificationState(MessageParcel & data,MessageParcel & reply)527 ErrCode AccessibleAbilityManagerServiceStub::HandleSetScreenMagnificationState(
528 MessageParcel& data, MessageParcel& reply)
529 {
530 HILOG_DEBUG();
531 if (!CheckPermission(OHOS_PERMISSION_WRITE_ACCESSIBILITY_CONFIG)) {
532 HILOG_WARN("Permission denied!");
533 reply.WriteInt32(RET_ERR_NO_PERMISSION);
534 return NO_ERROR;
535 }
536 bool state = data.ReadBool();
537
538 reply.WriteInt32(SetScreenMagnificationState(state));
539
540 return NO_ERROR;
541 }
542
HandleSetShortKeyState(MessageParcel & data,MessageParcel & reply)543 ErrCode AccessibleAbilityManagerServiceStub::HandleSetShortKeyState(MessageParcel &data, MessageParcel &reply)
544 {
545 HILOG_DEBUG();
546
547 if (!IsSystemApp()) {
548 HILOG_WARN("HandleSetShortKeyState Not system app");
549 reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
550 return NO_ERROR;
551 }
552 if (!CheckPermission(OHOS_PERMISSION_WRITE_ACCESSIBILITY_CONFIG)) {
553 HILOG_WARN("HandleSetShortKeyState Permission denied!");
554 reply.WriteInt32(RET_ERR_NO_PERMISSION);
555 return NO_ERROR;
556 }
557 bool state = data.ReadBool();
558
559 reply.WriteInt32(SetShortKeyState(state));
560
561 return NO_ERROR;
562 }
563
HandleSetMouseKeyState(MessageParcel & data,MessageParcel & reply)564 ErrCode AccessibleAbilityManagerServiceStub::HandleSetMouseKeyState(MessageParcel &data, MessageParcel &reply)
565 {
566 HILOG_DEBUG();
567
568 if (!IsSystemApp()) {
569 HILOG_WARN("HandleSetMouseKeyState Not system app");
570 reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
571 return NO_ERROR;
572 }
573 if (!CheckPermission(OHOS_PERMISSION_WRITE_ACCESSIBILITY_CONFIG)) {
574 HILOG_WARN("HandleSetMouseKeyState Permission denied!");
575 reply.WriteInt32(RET_ERR_NO_PERMISSION);
576 return NO_ERROR;
577 }
578 bool state = data.ReadBool();
579
580 reply.WriteInt32(SetMouseKeyState(state));
581
582 return NO_ERROR;
583 }
584
HandleSetShortkeyTarget(MessageParcel & data,MessageParcel & reply)585 ErrCode AccessibleAbilityManagerServiceStub::HandleSetShortkeyTarget(MessageParcel &data, MessageParcel &reply)
586 {
587 HILOG_DEBUG();
588
589 if (!IsSystemApp()) {
590 HILOG_WARN("HandleSetShortkeyTarget Not system app");
591 reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
592 return NO_ERROR;
593 }
594 if (!CheckPermission(OHOS_PERMISSION_WRITE_ACCESSIBILITY_CONFIG)) {
595 HILOG_WARN("HandleSetShortkeyTarget Permission denied!");
596 reply.WriteInt32(RET_ERR_NO_PERMISSION);
597 return NO_ERROR;
598 }
599 std::string name = data.ReadString();
600
601 reply.WriteInt32(SetShortkeyTarget(name));
602
603 return NO_ERROR;
604 }
605
HandleSetMouseAutoClick(MessageParcel & data,MessageParcel & reply)606 ErrCode AccessibleAbilityManagerServiceStub::HandleSetMouseAutoClick(MessageParcel &data, MessageParcel &reply)
607 {
608 HILOG_DEBUG();
609
610 if (!IsSystemApp()) {
611 HILOG_WARN("HandleSetMouseAutoClick Not system app");
612 reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
613 return NO_ERROR;
614 }
615 if (!CheckPermission(OHOS_PERMISSION_WRITE_ACCESSIBILITY_CONFIG)) {
616 HILOG_WARN("HandleSetMouseAutoClick Permission denied!");
617 reply.WriteInt32(RET_ERR_NO_PERMISSION);
618 return NO_ERROR;
619 }
620 int32_t time = data.ReadInt32();
621
622 reply.WriteInt32(SetMouseAutoClick(time));
623
624 return NO_ERROR;
625 }
626
HandleSetInvertColorState(MessageParcel & data,MessageParcel & reply)627 ErrCode AccessibleAbilityManagerServiceStub::HandleSetInvertColorState(MessageParcel &data, MessageParcel &reply)
628 {
629 HILOG_DEBUG();
630
631 if (!IsSystemApp()) {
632 HILOG_WARN("HandleSetInvertColorState Not system app");
633 reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
634 return NO_ERROR;
635 }
636 if (!CheckPermission(OHOS_PERMISSION_WRITE_ACCESSIBILITY_CONFIG)) {
637 HILOG_WARN("HandleSetInvertColorState Permission denied!");
638 reply.WriteInt32(RET_ERR_NO_PERMISSION);
639 return NO_ERROR;
640 }
641 bool state = data.ReadBool();
642
643 reply.WriteInt32(SetInvertColorState(state));
644
645 return NO_ERROR;
646 }
647
HandleSetHighContrastTextState(MessageParcel & data,MessageParcel & reply)648 ErrCode AccessibleAbilityManagerServiceStub::HandleSetHighContrastTextState(MessageParcel &data, MessageParcel &reply)
649 {
650 HILOG_DEBUG();
651
652 if (!IsSystemApp()) {
653 HILOG_WARN("HandleSetHighContrastTextState Not system app");
654 reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
655 return NO_ERROR;
656 }
657 if (!CheckPermission(OHOS_PERMISSION_WRITE_ACCESSIBILITY_CONFIG)) {
658 HILOG_WARN("HandleSetHighContrastTextState Permission denied!");
659 reply.WriteInt32(RET_ERR_NO_PERMISSION);
660 return NO_ERROR;
661 }
662 bool state = data.ReadBool();
663
664 reply.WriteInt32(SetHighContrastTextState(state));
665
666 return NO_ERROR;
667 }
668
HandleSetAudioMonoState(MessageParcel & data,MessageParcel & reply)669 ErrCode AccessibleAbilityManagerServiceStub::HandleSetAudioMonoState(MessageParcel &data, MessageParcel &reply)
670 {
671 HILOG_DEBUG();
672 if (!CheckPermission(OHOS_PERMISSION_WRITE_ACCESSIBILITY_CONFIG)) {
673 HILOG_WARN("Permission denied!");
674 reply.WriteInt32(RET_ERR_NO_PERMISSION);
675 return NO_ERROR;
676 }
677 bool state = data.ReadBool();
678
679 reply.WriteInt32(SetAudioMonoState(state));
680
681 return NO_ERROR;
682 }
683
684
HandleSetAnimationOffState(MessageParcel & data,MessageParcel & reply)685 ErrCode AccessibleAbilityManagerServiceStub::HandleSetAnimationOffState(MessageParcel &data, MessageParcel &reply)
686 {
687 HILOG_DEBUG();
688
689 if (!IsSystemApp()) {
690 HILOG_WARN("HandleSetAnimationOffState Not system app");
691 reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
692 return NO_ERROR;
693 }
694 if (!CheckPermission(OHOS_PERMISSION_WRITE_ACCESSIBILITY_CONFIG)) {
695 HILOG_WARN("HandleSetAnimationOffState Permission denied!");
696 reply.WriteInt32(RET_ERR_NO_PERMISSION);
697 return NO_ERROR;
698 }
699 bool state = data.ReadBool();
700
701 reply.WriteInt32(SetAnimationOffState(state));
702
703 return NO_ERROR;
704 }
705
HandleSetDaltonizationColorFilter(MessageParcel & data,MessageParcel & reply)706 ErrCode AccessibleAbilityManagerServiceStub::HandleSetDaltonizationColorFilter(
707 MessageParcel& data, MessageParcel& reply)
708 {
709 HILOG_DEBUG();
710
711 if (!IsSystemApp()) {
712 HILOG_WARN("HandleSetDaltonizationColorFilter Not system app");
713 reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
714 return NO_ERROR;
715 }
716 if (!CheckPermission(OHOS_PERMISSION_WRITE_ACCESSIBILITY_CONFIG)) {
717 HILOG_WARN("HandleSetDaltonizationColorFilter Permission denied!");
718 reply.WriteInt32(RET_ERR_NO_PERMISSION);
719 return NO_ERROR;
720 }
721 uint32_t filter = data.ReadUint32();
722
723 reply.WriteInt32(SetDaltonizationColorFilter(filter));
724
725 return NO_ERROR;
726 }
727
HandleSetContentTimeout(MessageParcel & data,MessageParcel & reply)728 ErrCode AccessibleAbilityManagerServiceStub::HandleSetContentTimeout(MessageParcel &data, MessageParcel &reply)
729 {
730 HILOG_DEBUG();
731
732 if (!IsSystemApp()) {
733 HILOG_WARN("HandleSetContentTimeout Not system app");
734 reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
735 return NO_ERROR;
736 }
737 if (!CheckPermission(OHOS_PERMISSION_WRITE_ACCESSIBILITY_CONFIG)) {
738 HILOG_WARN("HandleSetContentTimeout Permission denied!");
739 reply.WriteInt32(RET_ERR_NO_PERMISSION);
740 return NO_ERROR;
741 }
742 uint32_t time = data.ReadUint32();
743
744 reply.WriteInt32(SetContentTimeout(time));
745
746 return NO_ERROR;
747 }
748
HandleSetBrightnessDiscount(MessageParcel & data,MessageParcel & reply)749 ErrCode AccessibleAbilityManagerServiceStub::HandleSetBrightnessDiscount(MessageParcel &data, MessageParcel &reply)
750 {
751 HILOG_DEBUG();
752
753 if (!IsSystemApp()) {
754 HILOG_WARN("HandleSetBrightnessDiscount 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("HandleSetBrightnessDiscount Permission denied!");
760 reply.WriteInt32(RET_ERR_NO_PERMISSION);
761 return NO_ERROR;
762 }
763 float discount = data.ReadFloat();
764
765 reply.WriteInt32(SetBrightnessDiscount(discount));
766
767 return NO_ERROR;
768 }
769
HandleSetAudioBalance(MessageParcel & data,MessageParcel & reply)770 ErrCode AccessibleAbilityManagerServiceStub::HandleSetAudioBalance(MessageParcel &data, MessageParcel &reply)
771 {
772 HILOG_DEBUG();
773 if (!CheckPermission(OHOS_PERMISSION_WRITE_ACCESSIBILITY_CONFIG)) {
774 HILOG_WARN("Permission denied!");
775 reply.WriteInt32(RET_ERR_NO_PERMISSION);
776 return NO_ERROR;
777 }
778 float balance = data.ReadFloat();
779
780 reply.WriteInt32(SetAudioBalance(balance));
781
782 return NO_ERROR;
783 }
784
HandleGetScreenMagnificationState(MessageParcel & data,MessageParcel & reply)785 ErrCode AccessibleAbilityManagerServiceStub::HandleGetScreenMagnificationState(
786 MessageParcel& data, MessageParcel& reply)
787 {
788 HILOG_DEBUG();
789 bool result = false;
790 RetError ret = GetScreenMagnificationState(result);
791 reply.WriteInt32(ret);
792 if (ret == RET_OK) {
793 reply.WriteBool(result);
794 }
795 return NO_ERROR;
796 }
797
HandleGetShortKeyState(MessageParcel & data,MessageParcel & reply)798 ErrCode AccessibleAbilityManagerServiceStub::HandleGetShortKeyState(MessageParcel &data, MessageParcel &reply)
799 {
800 HILOG_DEBUG();
801
802 if (!IsSystemApp()) {
803 HILOG_WARN("Not system app");
804 reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
805 return NO_ERROR;
806 }
807 bool result = false;
808 RetError ret = GetShortKeyState(result);
809 reply.WriteInt32(ret);
810 if (ret == RET_OK) {
811 reply.WriteBool(result);
812 }
813 return NO_ERROR;
814 }
815
HandleGetMouseKeyState(MessageParcel & data,MessageParcel & reply)816 ErrCode AccessibleAbilityManagerServiceStub::HandleGetMouseKeyState(MessageParcel &data, MessageParcel &reply)
817 {
818 HILOG_DEBUG();
819
820 if (!IsSystemApp()) {
821 HILOG_WARN("Not system app");
822 reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
823 return NO_ERROR;
824 }
825 bool result = false;
826 RetError ret = GetMouseKeyState(result);
827 reply.WriteInt32(ret);
828 if (ret == RET_OK) {
829 reply.WriteBool(result);
830 }
831 return NO_ERROR;
832 }
833
HandleGetShortkeyTarget(MessageParcel & data,MessageParcel & reply)834 ErrCode AccessibleAbilityManagerServiceStub::HandleGetShortkeyTarget(MessageParcel &data, MessageParcel &reply)
835 {
836 HILOG_DEBUG();
837
838 if (!IsSystemApp()) {
839 HILOG_WARN("Not system app");
840 reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
841 return NO_ERROR;
842 }
843 std::string result = "";
844 RetError ret = GetShortkeyTarget(result);
845 reply.WriteInt32(ret);
846 if (ret == RET_OK) {
847 reply.WriteString(result);
848 }
849 return NO_ERROR;
850 }
851
HandleGetMouseAutoClick(MessageParcel & data,MessageParcel & reply)852 ErrCode AccessibleAbilityManagerServiceStub::HandleGetMouseAutoClick(MessageParcel &data, MessageParcel &reply)
853 {
854 HILOG_DEBUG();
855
856 if (!IsSystemApp()) {
857 HILOG_WARN("Not system app");
858 reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
859 return NO_ERROR;
860 }
861 int32_t result = 0;
862 RetError ret = GetMouseAutoClick(result);
863 reply.WriteInt32(ret);
864 if (ret == RET_OK) {
865 reply.WriteInt32(result);
866 }
867 return NO_ERROR;
868 }
869
HandleGetInvertColorState(MessageParcel & data,MessageParcel & reply)870 ErrCode AccessibleAbilityManagerServiceStub::HandleGetInvertColorState(MessageParcel &data, MessageParcel &reply)
871 {
872 HILOG_DEBUG();
873
874 if (!IsSystemApp()) {
875 HILOG_WARN("Not system app");
876 reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
877 return NO_ERROR;
878 }
879 bool result = false;
880 RetError ret = GetInvertColorState(result);
881 reply.WriteInt32(ret);
882 if (ret == RET_OK) {
883 reply.WriteBool(result);
884 }
885 return NO_ERROR;
886 }
887
HandleGetHighContrastTextState(MessageParcel & data,MessageParcel & reply)888 ErrCode AccessibleAbilityManagerServiceStub::HandleGetHighContrastTextState(MessageParcel &data, MessageParcel &reply)
889 {
890 HILOG_DEBUG();
891
892 if (!IsSystemApp()) {
893 HILOG_WARN("Not system app");
894 reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
895 return NO_ERROR;
896 }
897 bool result = false;
898 RetError ret = GetHighContrastTextState(result);
899 reply.WriteInt32(ret);
900 if (ret == RET_OK) {
901 reply.WriteBool(result);
902 }
903 return NO_ERROR;
904 }
905
HandleGetAudioMonoState(MessageParcel & data,MessageParcel & reply)906 ErrCode AccessibleAbilityManagerServiceStub::HandleGetAudioMonoState(MessageParcel &data, MessageParcel &reply)
907 {
908 HILOG_DEBUG();
909 bool result = false;
910 RetError ret = GetAudioMonoState(result);
911 reply.WriteInt32(ret);
912 if (ret == RET_OK) {
913 reply.WriteBool(result);
914 }
915 return NO_ERROR;
916 }
917
HandleGetAnimationOffState(MessageParcel & data,MessageParcel & reply)918 ErrCode AccessibleAbilityManagerServiceStub::HandleGetAnimationOffState(MessageParcel &data, MessageParcel &reply)
919 {
920 HILOG_DEBUG();
921
922 if (!IsSystemApp()) {
923 HILOG_WARN("Not system app");
924 reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
925 return NO_ERROR;
926 }
927 bool result = false;
928 RetError ret = GetAnimationOffState(result);
929 reply.WriteInt32(ret);
930 if (ret == RET_OK) {
931 reply.WriteBool(result);
932 }
933 return NO_ERROR;
934 }
935
HandleGetDaltonizationColorFilter(MessageParcel & data,MessageParcel & reply)936 ErrCode AccessibleAbilityManagerServiceStub::HandleGetDaltonizationColorFilter(
937 MessageParcel& data, MessageParcel& reply)
938 {
939 HILOG_DEBUG();
940
941 if (!IsSystemApp()) {
942 HILOG_WARN("Not system app");
943 reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
944 return NO_ERROR;
945 }
946 uint32_t result = 0;
947 RetError ret = GetDaltonizationColorFilter(result);
948 reply.WriteInt32(ret);
949 if (ret == RET_OK) {
950 reply.WriteUint32(result);
951 }
952 return NO_ERROR;
953 }
954
HandleGetContentTimeout(MessageParcel & data,MessageParcel & reply)955 ErrCode AccessibleAbilityManagerServiceStub::HandleGetContentTimeout(MessageParcel &data, MessageParcel &reply)
956 {
957 HILOG_DEBUG();
958
959 if (!IsSystemApp()) {
960 HILOG_WARN("Not system app");
961 reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
962 return NO_ERROR;
963 }
964 uint32_t result = 0;
965 RetError ret = GetContentTimeout(result);
966 reply.WriteInt32(ret);
967 if (ret == RET_OK) {
968 reply.WriteUint32(result);
969 }
970 return NO_ERROR;
971 }
972
HandleGetBrightnessDiscount(MessageParcel & data,MessageParcel & reply)973 ErrCode AccessibleAbilityManagerServiceStub::HandleGetBrightnessDiscount(MessageParcel &data, MessageParcel &reply)
974 {
975 HILOG_DEBUG();
976
977 if (!IsSystemApp()) {
978 HILOG_WARN("Not system app");
979 reply.WriteInt32(RET_ERR_NOT_SYSTEM_APP);
980 return NO_ERROR;
981 }
982 float result = 0;
983 RetError ret = GetBrightnessDiscount(result);
984 reply.WriteInt32(ret);
985 if (ret == RET_OK) {
986 reply.WriteFloat(result);
987 }
988 return NO_ERROR;
989 }
990
HandleGetAudioBalance(MessageParcel & data,MessageParcel & reply)991 ErrCode AccessibleAbilityManagerServiceStub::HandleGetAudioBalance(MessageParcel &data, MessageParcel &reply)
992 {
993 HILOG_DEBUG();
994 float result = 0;
995 RetError ret = GetAudioBalance(result);
996 reply.WriteInt32(ret);
997 if (ret == RET_OK) {
998 reply.WriteFloat(result);
999 }
1000 return NO_ERROR;
1001 }
1002
HandleGetAllConfigs(MessageParcel & data,MessageParcel & reply)1003 ErrCode AccessibleAbilityManagerServiceStub::HandleGetAllConfigs(MessageParcel &data, MessageParcel &reply)
1004 {
1005 HILOG_DEBUG();
1006
1007 AccessibilityConfigData configData;
1008 GetAllConfigs(configData);
1009 CaptionPropertyParcel captionParcel(configData.captionProperty_);
1010 reply.WriteBool(configData.highContrastText_);
1011 reply.WriteBool(configData.invertColor_);
1012 reply.WriteBool(configData.animationOff_);
1013 reply.WriteBool(configData.audioMono_);
1014 reply.WriteBool(configData.mouseKey_);
1015 reply.WriteBool(configData.captionState_);
1016 reply.WriteBool(configData.screenMagnifier_);
1017 reply.WriteBool(configData.shortkey_);
1018 reply.WriteInt32(configData.mouseAutoClick_);
1019 reply.WriteUint32(configData.daltonizationColorFilter_);
1020 reply.WriteUint32(configData.contentTimeout_);
1021 reply.WriteFloat(configData.brightnessDiscount_);
1022 reply.WriteFloat(configData.audioBalance_);
1023 reply.WriteString(configData.shortkeyTarget_);
1024 reply.WriteParcelable(&captionParcel);
1025 return NO_ERROR;
1026 }
1027
HandleRegisterEnableAbilityListsObserver(MessageParcel & data,MessageParcel & reply)1028 ErrCode AccessibleAbilityManagerServiceStub::HandleRegisterEnableAbilityListsObserver(
1029 MessageParcel &data, MessageParcel &reply)
1030 {
1031 HILOG_DEBUG();
1032 sptr<IRemoteObject> obj = data.ReadRemoteObject();
1033 sptr<IAccessibilityEnableAbilityListsObserver> observer =
1034 iface_cast<IAccessibilityEnableAbilityListsObserver>(obj);
1035 RegisterEnableAbilityListsObserver(observer);
1036
1037 return NO_ERROR;
1038 }
1039
HandleRegisterConfigCallback(MessageParcel & data,MessageParcel & reply)1040 ErrCode AccessibleAbilityManagerServiceStub::HandleRegisterConfigCallback(
1041 MessageParcel &data, MessageParcel &reply)
1042 {
1043 HILOG_DEBUG();
1044
1045 sptr<IRemoteObject> obj = data.ReadRemoteObject();
1046 sptr<IAccessibleAbilityManagerConfigObserver> config = iface_cast<IAccessibleAbilityManagerConfigObserver>(obj);
1047 uint64_t result = RegisterConfigObserver(config);
1048 reply.WriteUint64(result);
1049
1050 return NO_ERROR;
1051 }
1052 } // namespace Accessibility
1053 } // namespace OHOS