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