1 /*
2 * Copyright (C) 2022-2025 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 "accessibility_config_impl.h"
17 #include "hilog_wrapper.h"
18 #include "if_system_ability_manager.h"
19 #include "iservice_registry.h"
20 #include "parameter.h"
21 #include "system_ability_definition.h"
22
23 namespace OHOS {
24 namespace AccessibilityConfig {
25 namespace {
26 const std::string SYSTEM_PARAMETER_AAMS_NAME = "accessibility.config.ready";
27 constexpr int32_t CONFIG_PARAMETER_VALUE_SIZE = 10;
28 constexpr int32_t SA_CONNECT_TIMEOUT = 6 * 1000; // ms
29 constexpr uint32_t DISPLAY_DALTONIZER_GREEN = 12;
30 constexpr uint32_t DISPLAY_DALTONIZER_RED = 11;
31 constexpr uint32_t DISPLAY_DALTONIZER_BLUE = 13;
32 constexpr int32_t REPORTER_THRESHOLD_VALUE = 10;
33 }
34
Impl()35 AccessibilityConfig::Impl::Impl()
36 {}
37
~Impl()38 AccessibilityConfig::Impl::~Impl()
39 {
40 if (captionObserver_ != nullptr) {
41 captionObserver_->OnclientDeleted();
42 }
43
44 if (configObserver_ != nullptr) {
45 configObserver_->OnclientDeleted();
46 }
47
48 if (enableAbilityListsObserver_ != nullptr) {
49 enableAbilityListsObserver_->OnclientDeleted();
50 }
51
52 HILOG_INFO("AccessibilityConfig destory");
53 RemoveParameterWatcher(SYSTEM_PARAMETER_AAMS_NAME.c_str(), &OnParameterChanged, this);
54 }
55
InitializeContext()56 bool AccessibilityConfig::Impl::InitializeContext()
57 {
58 HILOG_DEBUG();
59 std::unique_lock<ffrt::shared_mutex> wLock(rwLock_);
60 if (isInitialized_) {
61 HILOG_DEBUG("Context has initialized");
62 return true;
63 }
64 isInitialized_ = ConnectToService();
65 return isInitialized_;
66 }
67
UnInitializeContext()68 void AccessibilityConfig::Impl::UnInitializeContext()
69 {
70 HILOG_DEBUG();
71 if (serviceProxy_ == nullptr) {
72 HILOG_ERROR("Context UnInitializeContext failed");
73 return;
74 }
75 sptr<IRemoteObject> object = serviceProxy_->AsObject();
76 ResetService(object);
77 }
78
OnParameterChanged(const char * key,const char * value,void * context)79 void AccessibilityConfig::Impl::OnParameterChanged(const char *key, const char *value, void *context)
80 {
81 if (!key || !value || !context) {
82 return;
83 }
84
85 std::string strKey(key);
86 std::string strValue(value);
87 if (strKey != SYSTEM_PARAMETER_AAMS_NAME || strValue != "true") {
88 return;
89 }
90 Impl* implPtr = static_cast<Impl*>(context);
91 if (implPtr->ConnectToServiceAsync() == true) {
92 HILOG_INFO("ConnectToServiceAsync success.");
93 } else {
94 HILOG_ERROR("ConnectToServiceAsync failed.");
95 }
96 }
97
ConnectToService()98 bool AccessibilityConfig::Impl::ConnectToService()
99 {
100 char value[CONFIG_PARAMETER_VALUE_SIZE] = "default";
101 int retSysParam = GetParameter(SYSTEM_PARAMETER_AAMS_NAME.c_str(), "false", value, CONFIG_PARAMETER_VALUE_SIZE);
102 if (retSysParam >= 0 && !std::strcmp(value, "true")) {
103 // Accessibility service is ready
104 if (!InitAccessibilityServiceProxy()) {
105 return false;
106 }
107
108 if (!RegisterToService()) {
109 return false;
110 }
111
112 InitConfigValues();
113 } else {
114 HILOG_DEBUG("Start watching accessibility service.");
115 retSysParam = WatchParameter(SYSTEM_PARAMETER_AAMS_NAME.c_str(), &OnParameterChanged, this);
116 if (retSysParam) {
117 HILOG_ERROR("Watch parameter failed, error = %{public}d", retSysParam);
118 return false;
119 }
120 }
121 return true;
122 }
123
ConnectToServiceAsync()124 bool AccessibilityConfig::Impl::ConnectToServiceAsync()
125 {
126 HILOG_DEBUG("ConnectToServiceAsync start.");
127 std::unique_lock<ffrt::shared_mutex> wLock(rwLock_);
128 if (InitAccessibilityServiceProxy()) {
129 (void)RegisterToService();
130 InitConfigValues();
131 isInitialized_ = true;
132 return true;
133 } else {
134 HILOG_ERROR("ConnectToServiceAsync fail");
135 return false;
136 }
137 }
138
InitAccessibilityServiceProxy()139 bool AccessibilityConfig::Impl::InitAccessibilityServiceProxy()
140 {
141 HILOG_DEBUG();
142 if (serviceProxy_ != nullptr) {
143 return true;
144 }
145 auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
146 if (samgr == nullptr) {
147 return false;
148 }
149 auto object = samgr->GetSystemAbility(ACCESSIBILITY_MANAGER_SERVICE_ID);
150 if (object != nullptr) {
151 if (deathRecipient_ == nullptr) {
152 deathRecipient_ = new(std::nothrow) DeathRecipient(*this);
153 if (deathRecipient_ == nullptr) {
154 HILOG_ERROR("create deathRecipient_ fail");
155 return false;
156 }
157 }
158
159 if (object->IsProxyObject() && !object->AddDeathRecipient(deathRecipient_)) {
160 HILOG_ERROR("Failed to add death recipient");
161 return false;
162 }
163
164 serviceProxy_ = iface_cast<Accessibility::IAccessibleAbilityManagerService>(object);
165 if (serviceProxy_ == nullptr) {
166 HILOG_ERROR("IAccessibleAbilityManagerService iface_cast failed");
167 return false;
168 }
169 HILOG_DEBUG("InitAccessibilityServiceProxy success");
170 return true;
171 } else {
172 if (LoadAccessibilityService() == false) {
173 HILOG_ERROR("LoadSystemAbilityService failed.");
174 return false;
175 } else {
176 return true;
177 }
178 }
179 return true;
180 }
181
LoadAccessibilityService()182 bool AccessibilityConfig::Impl::LoadAccessibilityService()
183 {
184 std::unique_lock<ffrt::mutex> lock(conVarMutex_);
185 sptr<AccessibilityLoadCallback> loadCallback = new AccessibilityLoadCallback(this);
186 if (loadCallback == nullptr) {
187 return false;
188 }
189 auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
190 if (samgr == nullptr) {
191 return false;
192 }
193 int32_t ret = samgr->LoadSystemAbility(ACCESSIBILITY_MANAGER_SERVICE_ID, loadCallback);
194 if (ret != 0) {
195 return false;
196 }
197 auto waitStatus = proxyConVar_.wait_for(lock, std::chrono::milliseconds(SA_CONNECT_TIMEOUT),
198 [this]() { return serviceProxy_ != nullptr; });
199 if (!waitStatus) {
200 return false;
201 }
202 (void)RegisterToService();
203 InitConfigValues();
204 return true;
205 }
206
LoadSystemAbilitySuccess(const sptr<IRemoteObject> & remoteObject)207 void AccessibilityConfig::Impl::LoadSystemAbilitySuccess(const sptr<IRemoteObject> &remoteObject)
208 {
209 std::lock_guard<ffrt::mutex> lock(conVarMutex_);
210 char value[CONFIG_PARAMETER_VALUE_SIZE] = "default";
211 int retSysParam = GetParameter(SYSTEM_PARAMETER_AAMS_NAME.c_str(), "false", value, CONFIG_PARAMETER_VALUE_SIZE);
212 if (retSysParam >= 0 && std::strcmp(value, "true")) {
213 do {
214 auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
215 if (samgr == nullptr) {
216 break;
217 }
218 auto object = samgr->GetSystemAbility(ACCESSIBILITY_MANAGER_SERVICE_ID);
219 if (object == nullptr) {
220 break;
221 }
222 deathRecipient_ = new(std::nothrow) DeathRecipient(*this);
223 if (deathRecipient_ == nullptr) {
224 break;
225 }
226 if (object->IsProxyObject()) {
227 object->AddDeathRecipient(deathRecipient_);
228 }
229 serviceProxy_ = iface_cast<Accessibility::IAccessibleAbilityManagerService>(object);
230 } while (0);
231 }
232 proxyConVar_.notify_one();
233 }
234
LoadSystemAbilityFail()235 void AccessibilityConfig::Impl::LoadSystemAbilityFail()
236 {
237 std::lock_guard<ffrt::mutex> lock(conVarMutex_);
238 HILOG_WARN("LoadSystemAbilityFail.");
239 proxyConVar_.notify_one();
240 }
241
RegisterToService()242 bool AccessibilityConfig::Impl::RegisterToService()
243 {
244 if (serviceProxy_ == nullptr) {
245 HILOG_ERROR("Service is not connected");
246 return false;
247 }
248
249 if (captionObserver_ && enableAbilityListsObserver_ && configObserver_) {
250 HILOG_DEBUG("Observers is registered");
251 return true;
252 }
253
254 if (captionObserver_ == nullptr) {
255 captionObserver_ = new(std::nothrow) AccessibleAbilityManagerCaptionObserverImpl(*this);
256 if (captionObserver_ == nullptr) {
257 HILOG_ERROR("Create captionObserver_ failed.");
258 return false;
259 }
260 ErrCode ret = serviceProxy_->RegisterCaptionObserver(captionObserver_);
261 if (ret != ERR_OK) {
262 captionObserver_ = nullptr;
263 HILOG_ERROR("Register captionObserver failed.");
264 return false;
265 }
266 }
267
268 if (!enableAbilityListsObserver_) {
269 enableAbilityListsObserver_ = new(std::nothrow) AccessibilityEnableAbilityListsObserverImpl(*this);
270 if (enableAbilityListsObserver_ == nullptr) {
271 HILOG_ERROR("Create enableAbilityListsObserver_ failed.");
272 return false;
273 }
274 serviceProxy_->RegisterEnableAbilityListsObserver(enableAbilityListsObserver_);
275 }
276
277 if (!configObserver_) {
278 configObserver_ = new(std::nothrow) AccessibleAbilityManagerConfigObserverImpl(*this);
279 if (configObserver_ == nullptr) {
280 HILOG_ERROR("Create configObserver_ failed.");
281 return false;
282 }
283 ErrCode ret = serviceProxy_->RegisterConfigObserver(configObserver_);
284 if (ret != ERR_OK) {
285 configObserver_ = nullptr;
286 HILOG_ERROR("Register configObserver failed.");
287 return false;
288 }
289 }
290
291 HILOG_DEBUG("RegisterToService succeaddss");
292 return true;
293 }
294
GetServiceProxy()295 sptr<Accessibility::IAccessibleAbilityManagerService> AccessibilityConfig::Impl::GetServiceProxy()
296 {
297 if (serviceProxy_ == nullptr) {
298 LoadAccessibilityService();
299 }
300 return serviceProxy_;
301 }
302
ResetService(const wptr<IRemoteObject> & remote)303 void AccessibilityConfig::Impl::ResetService(const wptr<IRemoteObject> &remote)
304 {
305 HILOG_DEBUG();
306 std::unique_lock<ffrt::shared_mutex> wLock(rwLock_);
307 if (serviceProxy_ != nullptr) {
308 sptr<IRemoteObject> object = serviceProxy_->AsObject();
309 if (object != nullptr && (remote == object)) {
310 object->RemoveDeathRecipient(deathRecipient_);
311 serviceProxy_ = nullptr;
312 captionObserver_ = nullptr;
313 enableAbilityListsObserver_ = nullptr;
314 configObserver_ = nullptr;
315 isInitialized_ = false;
316 HILOG_INFO("ResetService ok");
317 }
318 }
319 }
320
CheckSaStatus()321 bool AccessibilityConfig::Impl::CheckSaStatus()
322 {
323 std::vector<int> dependentSa = {
324 ABILITY_MGR_SERVICE_ID,
325 BUNDLE_MGR_SERVICE_SYS_ABILITY_ID,
326 COMMON_EVENT_SERVICE_ID,
327 DISPLAY_MANAGER_SERVICE_SA_ID,
328 SUBSYS_ACCOUNT_SYS_ABILITY_ID_BEGIN,
329 WINDOW_MANAGER_SERVICE_ID
330 };
331 auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
332 if (samgr == nullptr) {
333 return false;
334 }
335
336 if (std::any_of(dependentSa.begin(), dependentSa.end(), [&](int saId) {
337 return samgr->CheckSystemAbility(saId) == nullptr;
338 })) {
339 return false;
340 }
341 return true;
342 }
343
EnableAbility(const std::string & name,const uint32_t capabilities)344 Accessibility::RetError AccessibilityConfig::Impl::EnableAbility(const std::string &name, const uint32_t capabilities)
345 {
346 HILOG_INFO("name = [%{private}s] capabilities = [%{private}u]", name.c_str(), capabilities);
347 std::shared_lock<ffrt::shared_mutex> rLock(rwLock_);
348 if (GetServiceProxy() == nullptr) {
349 HILOG_ERROR("Failed to get accessibility service");
350 return Accessibility::RET_ERR_SAMGR;
351 }
352 Accessibility::RetError ret = static_cast<Accessibility::RetError>(GetServiceProxy()->EnableAbility(name,
353 capabilities));
354 return ret;
355 }
356
DisableAbility(const std::string & name)357 Accessibility::RetError AccessibilityConfig::Impl::DisableAbility(const std::string &name)
358 {
359 HILOG_INFO("name = [%{private}s]", name.c_str());
360 std::shared_lock<ffrt::shared_mutex> rLock(rwLock_);
361 if (GetServiceProxy() == nullptr) {
362 HILOG_ERROR("Failed to get accessibility service");
363 return Accessibility::RET_ERR_SAMGR;
364 }
365 Accessibility::RetError ret = static_cast<Accessibility::RetError>(GetServiceProxy()->DisableAbility(name));
366 return ret;
367 }
368
SetMagnificationState(const bool state)369 Accessibility::RetError AccessibilityConfig::Impl::SetMagnificationState(const bool state)
370 {
371 HILOG_INFO("state = [%{public}d]", state);
372 std::shared_lock<ffrt::shared_mutex> rLock(rwLock_);
373 if (GetServiceProxy() == nullptr) {
374 HILOG_ERROR("Failed to get accessibility service");
375 return Accessibility::RET_ERR_SAMGR;
376 }
377 Accessibility::RetError ret = static_cast<Accessibility::RetError>(
378 GetServiceProxy()->SetMagnificationState(state));
379 return ret;
380 }
381
GetCaptionsState(bool & state)382 Accessibility::RetError AccessibilityConfig::Impl::GetCaptionsState(bool &state)
383 {
384 std::shared_lock<ffrt::shared_mutex> rLock(rwLock_);
385 if (GetServiceProxy() == nullptr) {
386 HILOG_ERROR("Failed to get accessibility service");
387 return Accessibility::RET_ERR_SAMGR;
388 }
389 Accessibility::RetError ret = static_cast<Accessibility::RetError>(GetServiceProxy()->GetCaptionState(state));
390 HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
391 return ret;
392 }
393
GetCaptionsProperty(CaptionProperty & caption)394 Accessibility::RetError AccessibilityConfig::Impl::GetCaptionsProperty(CaptionProperty &caption)
395 {
396 std::shared_lock<ffrt::shared_mutex> rLock(rwLock_);
397 if (GetServiceProxy() == nullptr) {
398 HILOG_ERROR("Failed to get accessibility service");
399 return Accessibility::RET_ERR_SAMGR;
400 }
401 CaptionPropertyParcel captionParcel(caption);
402 Accessibility::RetError ret = static_cast<Accessibility::RetError>(
403 GetServiceProxy()->GetCaptionProperty(captionParcel));
404 HILOG_INFO();
405 return ret;
406 }
407
SetCaptionsProperty(const CaptionProperty & caption)408 Accessibility::RetError AccessibilityConfig::Impl::SetCaptionsProperty(const CaptionProperty& caption)
409 {
410 HILOG_INFO();
411 std::shared_lock<ffrt::shared_mutex> rLock(rwLock_);
412 if (GetServiceProxy() == nullptr) {
413 HILOG_ERROR("Failed to get accessibility service");
414 return Accessibility::RET_ERR_SAMGR;
415 }
416 CaptionPropertyParcel captionParcel(caption);
417 Accessibility::RetError ret = static_cast<Accessibility::RetError>(GetServiceProxy()->SetCaptionProperty(
418 captionParcel));
419 return ret;
420 }
421
SetCaptionsState(const bool state)422 Accessibility::RetError AccessibilityConfig::Impl::SetCaptionsState(const bool state)
423 {
424 HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
425 std::shared_lock<ffrt::shared_mutex> rLock(rwLock_);
426 if (GetServiceProxy() == nullptr) {
427 HILOG_ERROR("Failed to get accessibility service");
428 return Accessibility::RET_ERR_SAMGR;
429 }
430 Accessibility::RetError ret = static_cast<Accessibility::RetError>(GetServiceProxy()->SetCaptionState(state));
431 return ret;
432 }
433
NotifyCaptionStateChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> & observers,const bool state)434 void AccessibilityConfig::Impl::NotifyCaptionStateChanged(
435 const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers, const bool state)
436 {
437 HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
438 for (auto &observer : observers) {
439 if (observer) {
440 ConfigValue configValue;
441 configValue.captionState = state;
442 observer->OnConfigChanged(CONFIG_CAPTION_STATE, configValue);
443 } else {
444 HILOG_ERROR("end configObservers_ is null");
445 }
446 }
447 }
448
NotifyCaptionChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> & observers,const CaptionProperty & captionProperty)449 void AccessibilityConfig::Impl::NotifyCaptionChanged(
450 const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers, const CaptionProperty &captionProperty)
451 {
452 HILOG_INFO();
453 for (auto &observer : observers) {
454 if (observer) {
455 ConfigValue configValue;
456 configValue.captionStyle = captionProperty_;
457 observer->OnConfigChanged(CONFIG_CAPTION_STYLE, configValue);
458 } else {
459 HILOG_ERROR("end observers is null");
460 }
461 }
462 }
463
SubscribeConfigObserver(const CONFIG_ID id,const std::shared_ptr<AccessibilityConfigObserver> & observer,const bool retFlag)464 Accessibility::RetError AccessibilityConfig::Impl::SubscribeConfigObserver(const CONFIG_ID id,
465 const std::shared_ptr<AccessibilityConfigObserver> &observer, const bool retFlag)
466 {
467 HILOG_DEBUG("id = [%{public}d]", static_cast<int32_t>(id));
468 std::lock_guard<ffrt::mutex> lock(configObserversMutex_);
469 std::map<CONFIG_ID, std::vector<std::shared_ptr<AccessibilityConfigObserver>>>::iterator it =
470 configObservers_.find(id);
471 if (it != configObservers_.end()) {
472 it->second.push_back(observer);
473 HILOG_DEBUG("configObservers->second.size%{public}zu", it->second.size());
474 } else {
475 std::vector<std::shared_ptr<AccessibilityConfigObserver>> ob;
476 ob.push_back(observer);
477 configObservers_.insert(std::make_pair(id, ob));
478 HILOG_DEBUG("configObservers->second.size%{public}zu", ob.size());
479 }
480
481 if (retFlag && observer) {
482 NotifyImmediately(id, observer);
483 }
484 return Accessibility::RET_OK;
485 }
486
UnsubscribeConfigObserver(const CONFIG_ID id,const std::shared_ptr<AccessibilityConfigObserver> & observer)487 Accessibility::RetError AccessibilityConfig::Impl::UnsubscribeConfigObserver(const CONFIG_ID id,
488 const std::shared_ptr<AccessibilityConfigObserver> &observer)
489 {
490 HILOG_INFO("id = [%{public}d]", static_cast<int32_t>(id));
491 std::lock_guard<ffrt::mutex> lock(configObserversMutex_);
492 std::map<CONFIG_ID, std::vector<std::shared_ptr<AccessibilityConfigObserver>>>::iterator it =
493 configObservers_.find(id);
494 if (it != configObservers_.end()) {
495 for (auto iter = it->second.begin(); iter != it->second.end(); iter++) {
496 if (*iter == observer) {
497 HILOG_DEBUG("erase observer");
498 it->second.erase(iter);
499 HILOG_DEBUG("observer's size is %{public}zu", it->second.size());
500 return Accessibility::RET_OK;
501 }
502 }
503 } else {
504 HILOG_DEBUG("%{public}d has not subscribed ", id);
505 }
506 return Accessibility::RET_OK;
507 }
508
OnAccessibleAbilityManagerCaptionPropertyChanged(const CaptionProperty & property)509 void AccessibilityConfig::Impl::OnAccessibleAbilityManagerCaptionPropertyChanged(const CaptionProperty& property)
510 {
511 HILOG_DEBUG();
512 std::vector<std::shared_ptr<AccessibilityConfigObserver>> observers;
513 {
514 std::lock_guard<ffrt::mutex> lock(configObserversMutex_);
515 if (captionProperty_.GetFontScale() == property.GetFontScale() &&
516 captionProperty_.GetFontColor() == property.GetFontColor() &&
517 !strcmp(captionProperty_.GetFontFamily().c_str(), property.GetFontFamily().c_str()) &&
518 !strcmp(captionProperty_.GetFontEdgeType().c_str(), property.GetFontEdgeType().c_str()) &&
519 captionProperty_.GetBackgroundColor() == property.GetBackgroundColor() &&
520 captionProperty_.GetWindowColor() == property.GetWindowColor()) {
521 return;
522 }
523 captionProperty_ = property;
524 std::map<CONFIG_ID, std::vector<std::shared_ptr<AccessibilityConfigObserver>>>::iterator it =
525 configObservers_.find(CONFIG_CAPTION_STYLE);
526 if (it == configObservers_.end()) {
527 return;
528 }
529 observers = it->second;
530 }
531
532 NotifyCaptionChanged(observers, property);
533 }
534
SetScreenMagnificationState(const bool state)535 Accessibility::RetError AccessibilityConfig::Impl::SetScreenMagnificationState(const bool state)
536 {
537 HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
538 std::shared_lock<ffrt::shared_mutex> rLock(rwLock_);
539 if (GetServiceProxy() == nullptr) {
540 HILOG_ERROR("Failed to get accessibility service");
541 return Accessibility::RET_ERR_SAMGR;
542 }
543 Accessibility::RetError ret = static_cast<Accessibility::RetError>(GetServiceProxy()->SetScreenMagnificationState(
544 state));
545 return ret;
546 }
547
SetShortKeyState(const bool state)548 Accessibility::RetError AccessibilityConfig::Impl::SetShortKeyState(const bool state)
549 {
550 HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
551 std::shared_lock<ffrt::shared_mutex> rLock(rwLock_);
552 if (GetServiceProxy() == nullptr) {
553 HILOG_ERROR("Failed to get accessibility service");
554 return Accessibility::RET_ERR_SAMGR;
555 }
556 Accessibility::RetError ret = static_cast<Accessibility::RetError>(GetServiceProxy()->SetShortKeyState(state));
557 return ret;
558 }
559
SetMouseKeyState(const bool state)560 Accessibility::RetError AccessibilityConfig::Impl::SetMouseKeyState(const bool state)
561 {
562 HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
563 std::shared_lock<ffrt::shared_mutex> rLock(rwLock_);
564 if (GetServiceProxy() == nullptr) {
565 HILOG_ERROR("Failed to get accessibility service");
566 return Accessibility::RET_ERR_SAMGR;
567 }
568 Accessibility::RetError ret = static_cast<Accessibility::RetError>(GetServiceProxy()->SetMouseKeyState(state));
569 return ret;
570 }
571
GetScreenMagnificationState(bool & state)572 Accessibility::RetError AccessibilityConfig::Impl::GetScreenMagnificationState(bool &state)
573 {
574 std::shared_lock<ffrt::shared_mutex> rLock(rwLock_);
575 if (GetServiceProxy() == nullptr) {
576 HILOG_ERROR("Failed to get accessibility service");
577 return Accessibility::RET_ERR_SAMGR;
578 }
579
580 Accessibility::RetError ret = static_cast<Accessibility::RetError>(GetServiceProxy()->GetScreenMagnificationState(
581 state));
582 HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
583 return ret;
584 }
585
GetShortKeyState(bool & state)586 Accessibility::RetError AccessibilityConfig::Impl::GetShortKeyState(bool &state)
587 {
588 std::shared_lock<ffrt::shared_mutex> rLock(rwLock_);
589 if (GetServiceProxy() == nullptr) {
590 HILOG_ERROR("Failed to get accessibility service");
591 return Accessibility::RET_ERR_SAMGR;
592 }
593
594 Accessibility::RetError ret = static_cast<Accessibility::RetError>(GetServiceProxy()->GetShortKeyState(state));
595 HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
596 return ret;
597 }
598
GetMouseKeyState(bool & state)599 Accessibility::RetError AccessibilityConfig::Impl::GetMouseKeyState(bool &state)
600 {
601 std::shared_lock<ffrt::shared_mutex> rLock(rwLock_);
602 if (GetServiceProxy() == nullptr) {
603 HILOG_ERROR("Failed to get accessibility service");
604 return Accessibility::RET_ERR_SAMGR;
605 }
606
607 Accessibility::RetError ret = static_cast<Accessibility::RetError>(GetServiceProxy()->GetMouseKeyState(state));
608 HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
609 return ret;
610 }
611
UpdateCaptionEnabled(const bool enabled)612 void AccessibilityConfig::Impl::UpdateCaptionEnabled(const bool enabled)
613 {
614 std::vector<std::shared_ptr<AccessibilityConfigObserver>> observers;
615 {
616 std::lock_guard<ffrt::mutex> lock(configObserversMutex_);
617 if (captionState_ == enabled) {
618 return;
619 }
620 captionState_ = enabled;
621 std::map<CONFIG_ID, std::vector<std::shared_ptr<AccessibilityConfigObserver>>>::iterator it =
622 configObservers_.find(CONFIG_CAPTION_STATE);
623 if (it == configObservers_.end()) {
624 return;
625 }
626 observers = it->second;
627 }
628 NotifyCaptionStateChanged(observers, enabled);
629 }
630
UpdateScreenMagnificationEnabled(const bool enabled)631 void AccessibilityConfig::Impl::UpdateScreenMagnificationEnabled(const bool enabled)
632 {
633 std::vector<std::shared_ptr<AccessibilityConfigObserver>> observers;
634 {
635 std::lock_guard<ffrt::mutex> lock(configObserversMutex_);
636 if (screenMagnifier_ == enabled) {
637 return;
638 }
639 screenMagnifier_ = enabled;
640 std::map<CONFIG_ID, std::vector<std::shared_ptr<AccessibilityConfigObserver>>>::iterator it =
641 configObservers_.find(CONFIG_SCREEN_MAGNIFICATION);
642 if (it == configObservers_.end()) {
643 return;
644 }
645 observers = it->second;
646 }
647 NotifyScreenMagnificationChanged(observers, enabled);
648 }
649
UpdateShortKeyEnabled(const bool enabled)650 void AccessibilityConfig::Impl::UpdateShortKeyEnabled(const bool enabled)
651 {
652 std::vector<std::shared_ptr<AccessibilityConfigObserver>> observers;
653 {
654 std::lock_guard<ffrt::mutex> lock(configObserversMutex_);
655 if (shortkey_ == enabled) {
656 return;
657 }
658 shortkey_ = enabled;
659 std::map<CONFIG_ID, std::vector<std::shared_ptr<AccessibilityConfigObserver>>>::iterator it =
660 configObservers_.find(CONFIG_SHORT_KEY);
661 if (it == configObservers_.end()) {
662 return;
663 }
664 observers = it->second;
665 }
666 NotifyShortKeyChanged(observers, enabled);
667 }
668
UpdateMouseKeyEnabled(const bool enabled)669 void AccessibilityConfig::Impl::UpdateMouseKeyEnabled(const bool enabled)
670 {
671 std::vector<std::shared_ptr<AccessibilityConfigObserver>> observers;
672 {
673 std::lock_guard<ffrt::mutex> lock(configObserversMutex_);
674 if (mouseKey_ == enabled) {
675 return;
676 }
677 mouseKey_ = enabled;
678 std::map<CONFIG_ID, std::vector<std::shared_ptr<AccessibilityConfigObserver>>>::iterator it =
679 configObservers_.find(CONFIG_MOUSE_KEY);
680 if (it == configObservers_.end()) {
681 return;
682 }
683 observers = it->second;
684 }
685 NotifyMouseKeyChanged(observers, enabled);
686 }
687
UpdateAudioMonoEnabled(const bool enabled)688 void AccessibilityConfig::Impl::UpdateAudioMonoEnabled(const bool enabled)
689 {
690 std::vector<std::shared_ptr<AccessibilityConfigObserver>> observers;
691 {
692 std::lock_guard<ffrt::mutex> lock(configObserversMutex_);
693 if (audioMono_ == enabled) {
694 return;
695 }
696 audioMono_ = enabled;
697 std::map<CONFIG_ID, std::vector<std::shared_ptr<AccessibilityConfigObserver>>>::iterator it =
698 configObservers_.find(CONFIG_AUDIO_MONO);
699 if (it == configObservers_.end()) {
700 return;
701 }
702 observers = it->second;
703 }
704 NotifyAudioMonoChanged(observers, enabled);
705 }
706
UpdateAnimationOffEnabled(const bool enabled)707 void AccessibilityConfig::Impl::UpdateAnimationOffEnabled(const bool enabled)
708 {
709 std::vector<std::shared_ptr<AccessibilityConfigObserver>> observers;
710 {
711 std::lock_guard<ffrt::mutex> lock(configObserversMutex_);
712 if (animationOff_ == enabled) {
713 return;
714 }
715 animationOff_ = enabled;
716 std::map<CONFIG_ID, std::vector<std::shared_ptr<AccessibilityConfigObserver>>>::iterator it =
717 configObservers_.find(CONFIG_ANIMATION_OFF);
718 if (it == configObservers_.end()) {
719 return;
720 }
721 observers = it->second;
722 }
723
724 NotifyAnimationOffChanged(observers, enabled);
725 }
726
UpdateInvertColorEnabled(const bool enabled)727 void AccessibilityConfig::Impl::UpdateInvertColorEnabled(const bool enabled)
728 {
729 std::vector<std::shared_ptr<AccessibilityConfigObserver>> observers;
730 {
731 std::lock_guard<ffrt::mutex> lock(configObserversMutex_);
732 if (invertColor_ == enabled) {
733 return;
734 }
735 invertColor_ = enabled;
736 std::map<CONFIG_ID, std::vector<std::shared_ptr<AccessibilityConfigObserver>>>::iterator it =
737 configObservers_.find(CONFIG_INVERT_COLOR);
738 if (it == configObservers_.end()) {
739 return;
740 }
741 observers = it->second;
742 }
743 NotifyInvertColorChanged(observers, enabled);
744 }
745
UpdateHighContrastTextEnabled(const bool enabled)746 void AccessibilityConfig::Impl::UpdateHighContrastTextEnabled(const bool enabled)
747 {
748 HILOG_INFO("enabled = [%{public}s]", enabled ? "True" : "False");
749 std::vector<std::shared_ptr<AccessibilityConfigObserver>> observers;
750 {
751 std::lock_guard<ffrt::mutex> lock(configObserversMutex_);
752 if (highContrastText_ == enabled) {
753 return;
754 }
755 highContrastText_ = enabled;
756 std::map<CONFIG_ID, std::vector<std::shared_ptr<AccessibilityConfigObserver>>>::iterator it =
757 configObservers_.find(CONFIG_HIGH_CONTRAST_TEXT);
758 if (it == configObservers_.end()) {
759 return;
760 }
761 observers = it->second;
762 }
763 NotifyHighContrastTextChanged(observers, enabled);
764 }
765
UpdateDaltonizationStateEnabled(const bool enabled)766 void AccessibilityConfig::Impl::UpdateDaltonizationStateEnabled(const bool enabled)
767 {
768 HILOG_INFO("enabled = [%{public}s]", enabled ? "True" : "False");
769 std::vector<std::shared_ptr<AccessibilityConfigObserver>> observers;
770 {
771 std::lock_guard<ffrt::mutex> lock(configObserversMutex_);
772 if (daltonizationState_ == enabled) {
773 return;
774 }
775 daltonizationState_ = enabled;
776 std::map<CONFIG_ID, std::vector<std::shared_ptr<AccessibilityConfigObserver>>>::iterator it =
777 configObservers_.find(CONFIG_DALTONIZATION_COLOR_FILTER);
778 if (it == configObservers_.end()) {
779 return;
780 }
781 observers = it->second;
782 }
783 NotifyDaltonizationStateChanged(observers, enabled);
784 if (!enabled) {
785 HILOG_DEBUG();
786 NotifyDaltonizationColorFilterChanged(observers, Normal);
787 } else {
788 HILOG_DEBUG();
789 NotifyDaltonizationColorFilterChanged(observers, daltonizationColorFilter_);
790 }
791 }
792
UpdateIgnoreRepeatClickStateEnabled(const bool enabled)793 void AccessibilityConfig::Impl::UpdateIgnoreRepeatClickStateEnabled(const bool enabled)
794 {
795 std::vector<std::shared_ptr<AccessibilityConfigObserver>> observers;
796 {
797 std::lock_guard<ffrt::mutex> lock(configObserversMutex_);
798 if (ignoreRepeatClickState_ == enabled) {
799 return;
800 }
801 ignoreRepeatClickState_ = enabled;
802 std::map<CONFIG_ID, std::vector<std::shared_ptr<AccessibilityConfigObserver>>>::iterator it =
803 configObservers_.find(CONFIG_IGNORE_REPEAT_CLICK_STATE);
804 if (it == configObservers_.end()) {
805 return;
806 }
807 observers = it->second;
808 }
809 NotifyIgnoreRepeatClickStateChanged(observers, enabled);
810 }
811
NotifyScreenMagnificationChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> & observers,const bool state)812 void AccessibilityConfig::Impl::NotifyScreenMagnificationChanged(
813 const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers, const bool state)
814 {
815 HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
816 for (auto &observer : observers) {
817 if (observer) {
818 ConfigValue configValue;
819 configValue.screenMagnifier = state;
820 observer->OnConfigChanged(CONFIG_SCREEN_MAGNIFICATION, configValue);
821 } else {
822 HILOG_ERROR("end configObservers_ is null");
823 }
824 }
825 }
826
NotifyShortKeyChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> & observers,const bool state)827 void AccessibilityConfig::Impl::NotifyShortKeyChanged(
828 const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers, const bool state)
829 {
830 HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
831 for (auto &observer : observers) {
832 if (observer) {
833 ConfigValue configValue;
834 configValue.shortkey = state;
835 observer->OnConfigChanged(CONFIG_SHORT_KEY, configValue);
836 } else {
837 HILOG_ERROR("end configObservers_ is null");
838 }
839 }
840 }
841
NotifyMouseKeyChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> & observers,const bool state)842 void AccessibilityConfig::Impl::NotifyMouseKeyChanged(
843 const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers, const bool state)
844 {
845 HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
846 for (auto &observer : observers) {
847 if (observer) {
848 ConfigValue configValue;
849 configValue.mouseKey = state;
850 observer->OnConfigChanged(CONFIG_MOUSE_KEY, configValue);
851 } else {
852 HILOG_ERROR("end configObservers_ is null");
853 }
854 }
855 }
856
NotifyInvertColorChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> & observers,const bool state)857 void AccessibilityConfig::Impl::NotifyInvertColorChanged(
858 const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers, const bool state)
859 {
860 HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
861 for (auto &observer : observers) {
862 if (observer) {
863 ConfigValue configValue;
864 configValue.invertColor = state;
865 observer->OnConfigChanged(CONFIG_INVERT_COLOR, configValue);
866 } else {
867 HILOG_ERROR("end configObservers_ is null");
868 }
869 }
870 }
871
NotifyHighContrastTextChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> & observers,const bool state)872 void AccessibilityConfig::Impl::NotifyHighContrastTextChanged(
873 const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers, const bool state)
874 {
875 HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
876 for (auto &observer : observers) {
877 if (observer) {
878 ConfigValue configValue;
879 configValue.highContrastText = state;
880 observer->OnConfigChanged(CONFIG_HIGH_CONTRAST_TEXT, configValue);
881 } else {
882 HILOG_ERROR("end configObservers_ is null");
883 }
884 }
885 }
886
NotifyDaltonizationStateChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> & observers,const bool state)887 void AccessibilityConfig::Impl::NotifyDaltonizationStateChanged(
888 const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers, const bool state)
889 {
890 HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
891 for (auto &observer : observers) {
892 if (observer) {
893 ConfigValue configValue;
894 configValue.daltonizationState = state;
895 observer->OnConfigChanged(CONFIG_DALTONIZATION_STATE, configValue);
896 } else {
897 HILOG_ERROR("end configObservers_ is null");
898 }
899 }
900 }
901
NotifyAudioMonoChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> & observers,const bool state)902 void AccessibilityConfig::Impl::NotifyAudioMonoChanged(
903 const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers, const bool state)
904 {
905 HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
906 for (auto &observer : observers) {
907 if (observer) {
908 ConfigValue configValue;
909 configValue.audioMono = state;
910 observer->OnConfigChanged(CONFIG_AUDIO_MONO, configValue);
911 } else {
912 HILOG_ERROR("end configObservers_ is null");
913 }
914 }
915 }
916
NotifyAnimationOffChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> & observers,const bool state)917 void AccessibilityConfig::Impl::NotifyAnimationOffChanged(
918 const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers, const bool state)
919 {
920 HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
921 for (auto &observer : observers) {
922 if (observer) {
923 ConfigValue configValue;
924 configValue.animationOff = state;
925 observer->OnConfigChanged(CONFIG_ANIMATION_OFF, configValue);
926 } else {
927 HILOG_ERROR("end configObservers_ is null");
928 }
929 }
930 }
931
SetMouseAutoClick(const int32_t time)932 Accessibility::RetError AccessibilityConfig::Impl::SetMouseAutoClick(const int32_t time)
933 {
934 HILOG_INFO("time = [%{public}d]", time);
935 std::shared_lock<ffrt::shared_mutex> rLock(rwLock_);
936 if (GetServiceProxy() == nullptr) {
937 HILOG_ERROR("Failed to get accessibility service");
938 return Accessibility::RET_ERR_SAMGR;
939 }
940 Accessibility::RetError ret = static_cast<Accessibility::RetError>(GetServiceProxy()->SetMouseAutoClick(time));
941 return ret;
942 }
943
SetShortkeyTarget(const std::string & name)944 Accessibility::RetError AccessibilityConfig::Impl::SetShortkeyTarget(const std::string& name)
945 {
946 HILOG_INFO("name = [%{public}s]", name.c_str());
947 std::shared_lock<ffrt::shared_mutex> rLock(rwLock_);
948 if (GetServiceProxy() == nullptr) {
949 HILOG_ERROR("Failed to get accessibility service");
950 return Accessibility::RET_ERR_SAMGR;
951 }
952 Accessibility::RetError ret = static_cast<Accessibility::RetError>(GetServiceProxy()->SetShortkeyTarget(name));
953 return ret;
954 }
955
SetShortkeyMultiTarget(const std::vector<std::string> & name)956 Accessibility::RetError AccessibilityConfig::Impl::SetShortkeyMultiTarget(const std::vector<std::string>& name)
957 {
958 HILOG_INFO("start");
959 std::shared_lock<ffrt::shared_mutex> rLock(rwLock_);
960 if (GetServiceProxy() == nullptr) {
961 HILOG_ERROR("Failed to get accessibility service");
962 return Accessibility::RET_ERR_SAMGR;
963 }
964 Accessibility::RetError ret = static_cast<Accessibility::RetError>(GetServiceProxy()->SetShortkeyMultiTarget(name));
965 return ret;
966 }
967
GetMouseAutoClick(int32_t & time)968 Accessibility::RetError AccessibilityConfig::Impl::GetMouseAutoClick(int32_t &time)
969 {
970 std::shared_lock<ffrt::shared_mutex> rLock(rwLock_);
971 if (GetServiceProxy() == nullptr) {
972 HILOG_ERROR("Failed to get accessibility service");
973 return Accessibility::RET_ERR_SAMGR;
974 }
975
976 Accessibility::RetError ret = static_cast<Accessibility::RetError>(GetServiceProxy()->GetMouseAutoClick(time));
977 HILOG_INFO("time = [%{public}d]", time);
978 return ret;
979 }
980
GetShortkeyTarget(std::string & name)981 Accessibility::RetError AccessibilityConfig::Impl::GetShortkeyTarget(std::string &name)
982 {
983 std::shared_lock<ffrt::shared_mutex> rLock(rwLock_);
984 if (GetServiceProxy() == nullptr) {
985 HILOG_ERROR("Failed to get accessibility service");
986 return Accessibility::RET_ERR_SAMGR;
987 }
988
989 Accessibility::RetError ret = static_cast<Accessibility::RetError>(GetServiceProxy()->GetShortkeyTarget(name));
990 HILOG_INFO("name = [%{public}s]", name.c_str());
991 return ret;
992 }
993
GetShortkeyMultiTarget(std::vector<std::string> & name)994 Accessibility::RetError AccessibilityConfig::Impl::GetShortkeyMultiTarget(std::vector<std::string> &name)
995 {
996 std::shared_lock<ffrt::shared_mutex> rLock(rwLock_);
997 if (GetServiceProxy() == nullptr) {
998 HILOG_ERROR("Failed to get accessibility service");
999 return Accessibility::RET_ERR_SAMGR;
1000 }
1001
1002 Accessibility::RetError ret = static_cast<Accessibility::RetError>(GetServiceProxy()->GetShortkeyMultiTarget(name));
1003 return ret;
1004 }
1005
NotifyShortkeyTargetChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> & observers,const std::string & shortkey_target)1006 void AccessibilityConfig::Impl::NotifyShortkeyTargetChanged(
1007 const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers, const std::string &shortkey_target)
1008 {
1009 HILOG_INFO("shortkey_target = [%{public}s]", shortkey_target.c_str());
1010 for (auto &observer : observers) {
1011 if (observer) {
1012 ConfigValue configValue;
1013 configValue.shortkey_target = shortkeyTarget_;
1014 observer->OnConfigChanged(CONFIG_SHORT_KEY_TARGET, configValue);
1015 } else {
1016 HILOG_ERROR("end configObservers_ is null");
1017 }
1018 }
1019 }
1020
NotifyShortkeyMultiTargetChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> & observers,const std::vector<std::string> & shortkeyMultiTarget)1021 void AccessibilityConfig::Impl::NotifyShortkeyMultiTargetChanged(
1022 const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers,
1023 const std::vector<std::string> &shortkeyMultiTarget)
1024 {
1025 HILOG_DEBUG("start");
1026 for (auto &observer : observers) {
1027 if (observer) {
1028 ConfigValue configValue;
1029 configValue.shortkeyMultiTarget = shortkeyMultiTarget;
1030 observer->OnConfigChanged(CONFIG_SHORT_KEY_MULTI_TARGET, configValue);
1031 } else {
1032 HILOG_ERROR("end configObservers_ is null");
1033 }
1034 }
1035 }
1036
NotifyMouseAutoClickChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> & observers,const uint32_t mouseAutoClick)1037 void AccessibilityConfig::Impl::NotifyMouseAutoClickChanged(
1038 const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers, const uint32_t mouseAutoClick)
1039 {
1040 HILOG_INFO("mouseAutoClick = [%{public}u]", mouseAutoClick);
1041 for (auto &observer : observers) {
1042 if (observer) {
1043 ConfigValue configValue;
1044 configValue.mouseAutoClick = mouseAutoClick_;
1045 observer->OnConfigChanged(CONFIG_MOUSE_AUTOCLICK, configValue);
1046 } else {
1047 HILOG_ERROR("end configObservers_ is null");
1048 }
1049 }
1050 }
1051
NotifyAudioBalanceChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> & observers,const float audioBalance)1052 void AccessibilityConfig::Impl::NotifyAudioBalanceChanged(
1053 const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers, const float audioBalance)
1054 {
1055 HILOG_INFO("audioBalance = [%{public}f]", audioBalance);
1056 for (auto &observer : observers) {
1057 if (observer) {
1058 ConfigValue configValue;
1059 configValue.audioBalance = audioBalance;
1060 observer->OnConfigChanged(CONFIG_AUDIO_BALANCE, configValue);
1061 } else {
1062 HILOG_ERROR("end configObservers_ is null");
1063 }
1064 }
1065 }
1066
NotifyBrightnessDiscountChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> & observers,const float brightnessDiscount)1067 void AccessibilityConfig::Impl::NotifyBrightnessDiscountChanged(
1068 const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers, const float brightnessDiscount)
1069 {
1070 HILOG_INFO("brightnessDiscount = [%{public}f]", brightnessDiscount);
1071 for (auto &observer : observers) {
1072 if (observer) {
1073 ConfigValue configValue;
1074 configValue.brightnessDiscount = brightnessDiscount;
1075 observer->OnConfigChanged(CONFIG_BRIGHTNESS_DISCOUNT, configValue);
1076 } else {
1077 HILOG_ERROR("end configObservers_ is null");
1078 }
1079 }
1080 }
1081
NotifyContentTimeoutChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> & observers,const uint32_t contentTimeout)1082 void AccessibilityConfig::Impl::NotifyContentTimeoutChanged(
1083 const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers, const uint32_t contentTimeout)
1084 {
1085 HILOG_INFO("contentTimeout = [%{public}u]", contentTimeout);
1086 for (auto &observer : observers) {
1087 if (observer) {
1088 ConfigValue configValue;
1089 configValue.contentTimeout = contentTimeout;
1090 observer->OnConfigChanged(CONFIG_CONTENT_TIMEOUT, configValue);
1091 } else {
1092 HILOG_ERROR("end configObservers_ is null");
1093 }
1094 }
1095 }
1096
NotifyDaltonizationColorFilterChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> & observers,const uint32_t daltonizationColorFilter)1097 void AccessibilityConfig::Impl::NotifyDaltonizationColorFilterChanged(
1098 const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers, const uint32_t daltonizationColorFilter)
1099 {
1100 HILOG_INFO("daltonizationColorFilter = [%{public}u], daltonizationState_ = [%{public}d]", daltonizationColorFilter,
1101 daltonizationState_);
1102 for (auto &observer : observers) {
1103 if (observer) {
1104 ConfigValue configValue;
1105 if (!daltonizationState_) {
1106 HILOG_DEBUG();
1107 configValue.daltonizationColorFilter = Normal;
1108 observer->OnConfigChanged(CONFIG_DALTONIZATION_COLOR_FILTER, configValue);
1109 } else {
1110 configValue.daltonizationColorFilter = static_cast<DALTONIZATION_TYPE>(daltonizationColorFilter);
1111 observer->OnConfigChanged(CONFIG_DALTONIZATION_COLOR_FILTER, configValue);
1112 }
1113 } else {
1114 HILOG_ERROR("end configObservers_ is null");
1115 }
1116 }
1117 }
1118
NotifyClickResponseTimeChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> & observers,const uint32_t clickResponseTime)1119 void AccessibilityConfig::Impl::NotifyClickResponseTimeChanged(
1120 const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers, const uint32_t clickResponseTime)
1121 {
1122 HILOG_INFO("daltonizationColorFilter = [%{public}u]", clickResponseTime);
1123 for (auto &observer : observers) {
1124 if (observer) {
1125 ConfigValue configValue;
1126 configValue.clickResponseTime = static_cast<CLICK_RESPONSE_TIME>(clickResponseTime);
1127 observer->OnConfigChanged(CONIFG_CLICK_RESPONSE_TIME, configValue);
1128 } else {
1129 HILOG_ERROR("end configObservers_ is null");
1130 }
1131 }
1132 }
1133
NotifyIgnoreRepeatClickTimeChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> & observers,const uint32_t time)1134 void AccessibilityConfig::Impl::NotifyIgnoreRepeatClickTimeChanged(
1135 const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers, const uint32_t time)
1136 {
1137 HILOG_INFO("daltonizationColorFilter = [%{public}u]", time);
1138 for (auto &observer : observers) {
1139 if (observer) {
1140 ConfigValue configValue;
1141 configValue.ignoreRepeatClickTime = static_cast<IGNORE_REPEAT_CLICK_TIME>(time);
1142 observer->OnConfigChanged(CONFIG_IGNORE_REPEAT_CLICK_TIME, configValue);
1143 } else {
1144 HILOG_ERROR("end configObservers_ is null");
1145 }
1146 }
1147 }
1148
NotifyIgnoreRepeatClickStateChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> & observers,const bool state)1149 void AccessibilityConfig::Impl::NotifyIgnoreRepeatClickStateChanged(
1150 const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers, const bool state)
1151 {
1152 HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
1153 for (auto &observer : observers) {
1154 if (observer) {
1155 ConfigValue configValue;
1156 configValue.ignoreRepeatClickState = state;
1157 observer->OnConfigChanged(CONFIG_IGNORE_REPEAT_CLICK_STATE, configValue);
1158 } else {
1159 HILOG_ERROR("end configObservers_ is null");
1160 }
1161 }
1162 }
1163
SetHighContrastTextState(const bool state)1164 Accessibility::RetError AccessibilityConfig::Impl::SetHighContrastTextState(const bool state)
1165 {
1166 HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
1167 std::shared_lock<ffrt::shared_mutex> rLock(rwLock_);
1168 if (GetServiceProxy() == nullptr) {
1169 HILOG_ERROR("Failed to get accessibility service");
1170 return Accessibility::RET_ERR_SAMGR;
1171 }
1172 Accessibility::RetError ret = static_cast<Accessibility::RetError>(GetServiceProxy()->SetHighContrastTextState(
1173 state));
1174 return ret;
1175 }
1176
SetInvertColorState(const bool state)1177 Accessibility::RetError AccessibilityConfig::Impl::SetInvertColorState(const bool state)
1178 {
1179 HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
1180 std::shared_lock<ffrt::shared_mutex> rLock(rwLock_);
1181 if (GetServiceProxy() == nullptr) {
1182 HILOG_ERROR("Failed to get accessibility service");
1183 return Accessibility::RET_ERR_SAMGR;
1184 }
1185 Accessibility::RetError ret = static_cast<Accessibility::RetError>(GetServiceProxy()->SetInvertColorState(state));
1186 return ret;
1187 }
1188
SetDaltonizationState(const bool state)1189 Accessibility::RetError AccessibilityConfig::Impl::SetDaltonizationState(const bool state)
1190 {
1191 HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
1192 std::shared_lock<ffrt::shared_mutex> rLock(rwLock_);
1193 if (GetServiceProxy() == nullptr) {
1194 HILOG_ERROR("Failed to get accessibility service");
1195 return Accessibility::RET_ERR_SAMGR;
1196 }
1197 Accessibility::RetError ret = static_cast<Accessibility::RetError>(GetServiceProxy()->SetDaltonizationState(state));
1198 return ret;
1199 }
1200
SetDaltonizationColorFilter(const DALTONIZATION_TYPE type)1201 Accessibility::RetError AccessibilityConfig::Impl::SetDaltonizationColorFilter(const DALTONIZATION_TYPE type)
1202 {
1203 HILOG_INFO("type = [%{public}u]", static_cast<uint32_t>(type));
1204 std::shared_lock<ffrt::shared_mutex> rLock(rwLock_);
1205 if (GetServiceProxy() == nullptr) {
1206 HILOG_ERROR("Failed to get accessibility service");
1207 return Accessibility::RET_ERR_SAMGR;
1208 }
1209 Accessibility::RetError ret = static_cast<Accessibility::RetError>(GetServiceProxy()->SetDaltonizationColorFilter(
1210 type));
1211 return ret;
1212 }
1213
SetContentTimeout(const uint32_t timer)1214 Accessibility::RetError AccessibilityConfig::Impl::SetContentTimeout(const uint32_t timer)
1215 {
1216 HILOG_INFO("timer = [%{public}u]", timer);
1217 std::shared_lock<ffrt::shared_mutex> rLock(rwLock_);
1218 if (GetServiceProxy() == nullptr) {
1219 HILOG_ERROR("Failed to get accessibility service");
1220 return Accessibility::RET_ERR_SAMGR;
1221 }
1222 Accessibility::RetError ret = static_cast<Accessibility::RetError>(GetServiceProxy()->SetContentTimeout(timer));
1223 return ret;
1224 }
1225
SetAnimationOffState(const bool state)1226 Accessibility::RetError AccessibilityConfig::Impl::SetAnimationOffState(const bool state)
1227 {
1228 HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
1229 std::shared_lock<ffrt::shared_mutex> rLock(rwLock_);
1230 if (GetServiceProxy() == nullptr) {
1231 HILOG_ERROR("Failed to get accessibility service");
1232 return Accessibility::RET_ERR_SAMGR;
1233 }
1234 Accessibility::RetError ret = static_cast<Accessibility::RetError>(GetServiceProxy()->SetAnimationOffState(state));
1235 return ret;
1236 }
1237
SetBrightnessDiscount(const float brightness)1238 Accessibility::RetError AccessibilityConfig::Impl::SetBrightnessDiscount(const float brightness)
1239 {
1240 HILOG_INFO("brightness = [%{public}f]", brightness);
1241 std::shared_lock<ffrt::shared_mutex> rLock(rwLock_);
1242 if (GetServiceProxy() == nullptr) {
1243 HILOG_ERROR("Failed to get accessibility service");
1244 return Accessibility::RET_ERR_SAMGR;
1245 }
1246 Accessibility::RetError ret = static_cast<Accessibility::RetError>(GetServiceProxy()->SetBrightnessDiscount(
1247 brightness));
1248 return ret;
1249 }
1250
SetAudioMonoState(const bool state)1251 Accessibility::RetError AccessibilityConfig::Impl::SetAudioMonoState(const bool state)
1252 {
1253 HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
1254 std::shared_lock<ffrt::shared_mutex> rLock(rwLock_);
1255 if (GetServiceProxy() == nullptr) {
1256 HILOG_ERROR("Failed to get accessibility service");
1257 return Accessibility::RET_ERR_SAMGR;
1258 }
1259 Accessibility::RetError ret = static_cast<Accessibility::RetError>(GetServiceProxy()->SetAudioMonoState(state));
1260 return ret;
1261 }
1262
SetAudioBalance(const float balance)1263 Accessibility::RetError AccessibilityConfig::Impl::SetAudioBalance(const float balance)
1264 {
1265 HILOG_INFO("balance = [%{public}f]", balance);
1266 std::shared_lock<ffrt::shared_mutex> rLock(rwLock_);
1267 if (GetServiceProxy() == nullptr) {
1268 HILOG_ERROR("Failed to get accessibility service");
1269 return Accessibility::RET_ERR_SAMGR;
1270 }
1271 Accessibility::RetError ret = static_cast<Accessibility::RetError>(GetServiceProxy()->SetAudioBalance(balance));
1272 return ret;
1273 }
1274
SetClickResponseTime(const CLICK_RESPONSE_TIME time)1275 Accessibility::RetError AccessibilityConfig::Impl::SetClickResponseTime(const CLICK_RESPONSE_TIME time)
1276 {
1277 HILOG_INFO("click response time = [%{public}u]", time);
1278 std::shared_lock<ffrt::shared_mutex> rLock(rwLock_);
1279 if (GetServiceProxy() == nullptr) {
1280 HILOG_ERROR("Failed to get accessibility service");
1281 return Accessibility::RET_ERR_SAMGR;
1282 }
1283 Accessibility::RetError ret = static_cast<Accessibility::RetError>(GetServiceProxy()->SetClickResponseTime(time));
1284 return ret;
1285 }
1286
SetIgnoreRepeatClickState(const bool state)1287 Accessibility::RetError AccessibilityConfig::Impl::SetIgnoreRepeatClickState(const bool state)
1288 {
1289 HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
1290 std::shared_lock<ffrt::shared_mutex> rLock(rwLock_);
1291 if (GetServiceProxy() == nullptr) {
1292 HILOG_ERROR("Failed to get accessibility service");
1293 return Accessibility::RET_ERR_SAMGR;
1294 }
1295 Accessibility::RetError ret = static_cast<Accessibility::RetError>(GetServiceProxy()->SetIgnoreRepeatClickState(
1296 state));
1297 return ret;
1298 }
1299
SetIgnoreRepeatClickTime(const IGNORE_REPEAT_CLICK_TIME time)1300 Accessibility::RetError AccessibilityConfig::Impl::SetIgnoreRepeatClickTime(const IGNORE_REPEAT_CLICK_TIME time)
1301 {
1302 HILOG_INFO("ignore repeat click time = [%{public}u]", time);
1303 std::shared_lock<ffrt::shared_mutex> rLock(rwLock_);
1304 if (GetServiceProxy() == nullptr) {
1305 HILOG_ERROR("Failed to get accessibility service");
1306 return Accessibility::RET_ERR_SAMGR;
1307 }
1308 Accessibility::RetError ret = static_cast<Accessibility::RetError>(GetServiceProxy()->SetIgnoreRepeatClickTime(
1309 time));
1310 return ret;
1311 }
1312
GetInvertColorState(bool & state)1313 Accessibility::RetError AccessibilityConfig::Impl::GetInvertColorState(bool &state)
1314 {
1315 std::shared_lock<ffrt::shared_mutex> rLock(rwLock_);
1316 if (GetServiceProxy() == nullptr) {
1317 HILOG_ERROR("Failed to get accessibility service");
1318 return Accessibility::RET_ERR_SAMGR;
1319 }
1320
1321 Accessibility::RetError ret = static_cast<Accessibility::RetError>(GetServiceProxy()->GetInvertColorState(state));
1322 HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
1323 return ret;
1324 }
1325
GetHighContrastTextState(bool & state)1326 Accessibility::RetError AccessibilityConfig::Impl::GetHighContrastTextState(bool &state)
1327 {
1328 std::shared_lock<ffrt::shared_mutex> rLock(rwLock_);
1329 if (GetServiceProxy() == nullptr) {
1330 HILOG_ERROR("Failed to get accessibility service");
1331 return Accessibility::RET_ERR_SAMGR;
1332 }
1333
1334 Accessibility::RetError ret = static_cast<Accessibility::RetError>(GetServiceProxy()->GetHighContrastTextState(
1335 state));
1336 HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
1337 return ret;
1338 }
1339
GetDaltonizationState(bool & state)1340 Accessibility::RetError AccessibilityConfig::Impl::GetDaltonizationState(bool &state)
1341 {
1342 std::shared_lock<ffrt::shared_mutex> rLock(rwLock_);
1343 if (GetServiceProxy() == nullptr) {
1344 HILOG_ERROR("Failed to get accessibility service");
1345 return Accessibility::RET_ERR_SAMGR;
1346 }
1347
1348 Accessibility::RetError ret = static_cast<Accessibility::RetError>(GetServiceProxy()->GetDaltonizationState(state));
1349 HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
1350 return ret;
1351 }
1352
GetDaltonizationColorFilter(DALTONIZATION_TYPE & type)1353 Accessibility::RetError AccessibilityConfig::Impl::GetDaltonizationColorFilter(DALTONIZATION_TYPE &type)
1354 {
1355 std::shared_lock<ffrt::shared_mutex> rLock(rwLock_);
1356 if (GetServiceProxy() == nullptr) {
1357 HILOG_ERROR("Failed to get accessibility service");
1358 return Accessibility::RET_ERR_SAMGR;
1359 }
1360
1361 uint32_t filterType = 0;
1362 Accessibility::RetError ret = static_cast<Accessibility::RetError>(GetServiceProxy()->GetDaltonizationColorFilter(
1363 filterType));
1364 type = static_cast<DALTONIZATION_TYPE>(filterType);
1365 HILOG_INFO("type = [%{public}u]", static_cast<uint32_t>(type));
1366 return ret;
1367 }
1368
GetContentTimeout(uint32_t & timer)1369 Accessibility::RetError AccessibilityConfig::Impl::GetContentTimeout(uint32_t &timer)
1370 {
1371 std::shared_lock<ffrt::shared_mutex> rLock(rwLock_);
1372 if (GetServiceProxy() == nullptr) {
1373 HILOG_ERROR("Failed to get accessibility service");
1374 return Accessibility::RET_ERR_SAMGR;
1375 }
1376
1377 Accessibility::RetError ret = static_cast<Accessibility::RetError>(GetServiceProxy()->GetContentTimeout(timer));
1378 HILOG_INFO("timer = [%{public}u]", timer);
1379 return ret;
1380 }
1381
GetAnimationOffState(bool & state)1382 Accessibility::RetError AccessibilityConfig::Impl::GetAnimationOffState(bool &state)
1383 {
1384 std::shared_lock<ffrt::shared_mutex> rLock(rwLock_);
1385 if (GetServiceProxy() == nullptr) {
1386 HILOG_ERROR("Failed to get accessibility service");
1387 return Accessibility::RET_ERR_SAMGR;
1388 }
1389
1390 Accessibility::RetError ret = static_cast<Accessibility::RetError>(GetServiceProxy()->GetAnimationOffState(state));
1391 HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
1392 return ret;
1393 }
1394
GetBrightnessDiscount(float & brightness)1395 Accessibility::RetError AccessibilityConfig::Impl::GetBrightnessDiscount(float &brightness)
1396 {
1397 std::shared_lock<ffrt::shared_mutex> rLock(rwLock_);
1398 if (GetServiceProxy() == nullptr) {
1399 HILOG_ERROR("Failed to get accessibility service");
1400 return Accessibility::RET_ERR_SAMGR;
1401 }
1402
1403 Accessibility::RetError ret = static_cast<Accessibility::RetError>(GetServiceProxy()->GetBrightnessDiscount(
1404 brightness));
1405 HILOG_INFO("brightness = [%{public}f]", brightness);
1406 return ret;
1407 }
1408
GetAudioMonoState(bool & state)1409 Accessibility::RetError AccessibilityConfig::Impl::GetAudioMonoState(bool &state)
1410 {
1411 std::shared_lock<ffrt::shared_mutex> rLock(rwLock_);
1412 if (GetServiceProxy() == nullptr) {
1413 HILOG_ERROR("Failed to get accessibility service");
1414 return Accessibility::RET_ERR_SAMGR;
1415 }
1416
1417 Accessibility::RetError ret = static_cast<Accessibility::RetError>(GetServiceProxy()->GetAudioMonoState(state));
1418 HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
1419 return ret;
1420 }
1421
GetAudioBalance(float & balance)1422 Accessibility::RetError AccessibilityConfig::Impl::GetAudioBalance(float &balance)
1423 {
1424 std::shared_lock<ffrt::shared_mutex> rLock(rwLock_);
1425 if (GetServiceProxy() == nullptr) {
1426 HILOG_ERROR("Failed to get accessibility service");
1427 return Accessibility::RET_ERR_SAMGR;
1428 }
1429
1430 Accessibility::RetError ret = static_cast<Accessibility::RetError>(GetServiceProxy()->GetAudioBalance(balance));
1431 HILOG_INFO("balance = [%{public}f]", balance);
1432 return ret;
1433 }
1434
GetClickResponseTime(CLICK_RESPONSE_TIME & time)1435 Accessibility::RetError AccessibilityConfig::Impl::GetClickResponseTime(CLICK_RESPONSE_TIME &time)
1436 {
1437 std::shared_lock<ffrt::shared_mutex> rLock(rwLock_);
1438 if (GetServiceProxy() == nullptr) {
1439 HILOG_ERROR("Failed to get accessibility service");
1440 return Accessibility::RET_ERR_SAMGR;
1441 }
1442
1443 uint32_t responseTime = 0;
1444 Accessibility::RetError ret = static_cast<Accessibility::RetError>(GetServiceProxy()->GetClickResponseTime(
1445 responseTime));
1446 time = static_cast<CLICK_RESPONSE_TIME>(responseTime);
1447 HILOG_INFO("click response time = [%{public}u]", time);
1448 return ret;
1449 }
1450
GetIgnoreRepeatClickState(bool & state)1451 Accessibility::RetError AccessibilityConfig::Impl::GetIgnoreRepeatClickState(bool &state)
1452 {
1453 std::shared_lock<ffrt::shared_mutex> rLock(rwLock_);
1454 if (GetServiceProxy() == nullptr) {
1455 HILOG_ERROR("Failed to get accessibility service");
1456 return Accessibility::RET_ERR_SAMGR;
1457 }
1458
1459 Accessibility::RetError ret = static_cast<Accessibility::RetError>(GetServiceProxy()->GetIgnoreRepeatClickState(
1460 state));
1461 HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
1462 return ret;
1463 }
1464
GetIgnoreRepeatClickTime(IGNORE_REPEAT_CLICK_TIME & time)1465 Accessibility::RetError AccessibilityConfig::Impl::GetIgnoreRepeatClickTime(IGNORE_REPEAT_CLICK_TIME &time)
1466 {
1467 std::shared_lock<ffrt::shared_mutex> rLock(rwLock_);
1468 if (GetServiceProxy() == nullptr) {
1469 HILOG_ERROR("Failed to get accessibility service");
1470 return Accessibility::RET_ERR_SAMGR;
1471 }
1472
1473 uint32_t ignoreRepeatClickTime = 0;
1474 Accessibility::RetError ret = static_cast<Accessibility::RetError>(GetServiceProxy()->GetIgnoreRepeatClickTime(
1475 ignoreRepeatClickTime));
1476 time = static_cast<IGNORE_REPEAT_CLICK_TIME>(ignoreRepeatClickTime);
1477 HILOG_INFO("ignore repeat click time = [%{public}u]", time);
1478 return ret;
1479 }
1480
SubscribeEnableAbilityListsObserver(const std::shared_ptr<AccessibilityEnableAbilityListsObserver> & observer)1481 Accessibility::RetError AccessibilityConfig::Impl::SubscribeEnableAbilityListsObserver(
1482 const std::shared_ptr<AccessibilityEnableAbilityListsObserver> &observer)
1483 {
1484 HILOG_INFO();
1485 std::lock_guard<ffrt::mutex> lock(enableAbilityListsObserversMutex_);
1486 if (std::any_of(enableAbilityListsObservers_.begin(), enableAbilityListsObservers_.end(),
1487 [&observer](const std::shared_ptr<AccessibilityEnableAbilityListsObserver> &listObserver) {
1488 return listObserver == observer;
1489 })) {
1490 HILOG_ERROR("the observer is exist");
1491 return Accessibility::RET_OK;
1492 }
1493 enableAbilityListsObservers_.push_back(observer);
1494 HILOG_DEBUG("observer's size is %{public}zu", enableAbilityListsObservers_.size());
1495 return Accessibility::RET_OK;
1496 }
1497
UnsubscribeEnableAbilityListsObserver(const std::shared_ptr<AccessibilityEnableAbilityListsObserver> & observer)1498 Accessibility::RetError AccessibilityConfig::Impl::UnsubscribeEnableAbilityListsObserver(
1499 const std::shared_ptr<AccessibilityEnableAbilityListsObserver> &observer)
1500 {
1501 HILOG_INFO();
1502 std::lock_guard<ffrt::mutex> lock(enableAbilityListsObserversMutex_);
1503 for (auto iter = enableAbilityListsObservers_.begin(); iter != enableAbilityListsObservers_.end(); iter++) {
1504 if (*iter == observer) {
1505 HILOG_DEBUG("erase observer");
1506 enableAbilityListsObservers_.erase(iter);
1507 HILOG_DEBUG("observer's size is %{public}zu", enableAbilityListsObservers_.size());
1508 return Accessibility::RET_OK;
1509 }
1510 }
1511 return Accessibility::RET_OK;
1512 }
1513
OnAccessibilityEnableAbilityListsChanged()1514 void AccessibilityConfig::Impl::OnAccessibilityEnableAbilityListsChanged()
1515 {
1516 HILOG_DEBUG("observer's size is %{public}zu", enableAbilityListsObservers_.size());
1517 std::vector<std::shared_ptr<AccessibilityEnableAbilityListsObserver>> observers;
1518 {
1519 std::lock_guard<ffrt::mutex> lock(enableAbilityListsObserversMutex_);
1520 observers = enableAbilityListsObservers_;
1521 }
1522 for (auto &enableAbilityListsObserver : observers) {
1523 enableAbilityListsObserver->OnEnableAbilityListsStateChanged();
1524 }
1525 }
1526
OnAccessibilityInstallAbilityListsChanged()1527 void AccessibilityConfig::Impl::OnAccessibilityInstallAbilityListsChanged()
1528 {
1529 HILOG_DEBUG("observer's size is %{public}zu", enableAbilityListsObservers_.size());
1530 std::vector<std::shared_ptr<AccessibilityEnableAbilityListsObserver>> observers;
1531 {
1532 std::lock_guard<ffrt::mutex> lock(enableAbilityListsObserversMutex_);
1533 observers = enableAbilityListsObservers_;
1534 }
1535 for (auto &enableAbilityListsObserver : observers) {
1536 if (enableAbilityListsObserver != nullptr) {
1537 enableAbilityListsObserver->OnInstallAbilityListsStateChanged();
1538 } else {
1539 HILOG_ERROR("enableAbilityListsObserver is null");
1540 }
1541 }
1542 }
1543
OnIgnoreRepeatClickStateChanged(const uint32_t stateType)1544 void AccessibilityConfig::Impl::OnIgnoreRepeatClickStateChanged(const uint32_t stateType)
1545 {
1546 if (stateType & Accessibility::STATE_IGNORE_REPEAT_CLICK_ENABLED) {
1547 UpdateIgnoreRepeatClickStateEnabled(true);
1548 } else {
1549 UpdateIgnoreRepeatClickStateEnabled(false);
1550 }
1551 }
1552
OnAccessibleAbilityManagerConfigStateChanged(const uint32_t stateType)1553 void AccessibilityConfig::Impl::OnAccessibleAbilityManagerConfigStateChanged(const uint32_t stateType)
1554 {
1555 HILOG_DEBUG("stateType = [%{public}u}", stateType);
1556 if (stateType & Accessibility::STATE_CAPTION_ENABLED) {
1557 UpdateCaptionEnabled(true);
1558 } else {
1559 UpdateCaptionEnabled(false);
1560 }
1561
1562 if (stateType & Accessibility::STATE_SCREENMAGNIFIER_ENABLED) {
1563 UpdateScreenMagnificationEnabled(true);
1564 } else {
1565 UpdateScreenMagnificationEnabled(false);
1566 }
1567
1568 if (stateType & Accessibility::STATE_SHORTKEY_ENABLED) {
1569 UpdateShortKeyEnabled(true);
1570 } else {
1571 UpdateShortKeyEnabled(false);
1572 }
1573
1574 if (stateType & Accessibility::STATE_AUDIOMONO_ENABLED) {
1575 UpdateAudioMonoEnabled(true);
1576 } else {
1577 UpdateAudioMonoEnabled(false);
1578 }
1579
1580 if (stateType & Accessibility::STATE_ANIMATIONOFF_ENABLED) {
1581 UpdateAnimationOffEnabled(true);
1582 } else {
1583 UpdateAnimationOffEnabled(false);
1584 }
1585
1586 if (stateType & Accessibility::STATE_INVETRTCOLOR_ENABLED) {
1587 UpdateInvertColorEnabled(true);
1588 } else {
1589 UpdateInvertColorEnabled(false);
1590 }
1591
1592 if (stateType & Accessibility::STATE_HIGHCONTRAST_ENABLED) {
1593 UpdateHighContrastTextEnabled(true);
1594 } else {
1595 UpdateHighContrastTextEnabled(false);
1596 }
1597
1598 if (stateType & Accessibility::STATE_DALTONIZATION_STATE_ENABLED) {
1599 UpdateDaltonizationStateEnabled(true);
1600 } else {
1601 UpdateDaltonizationStateEnabled(false);
1602 }
1603
1604 if (stateType & Accessibility::STATE_MOUSEKEY_ENABLED) {
1605 UpdateMouseKeyEnabled(true);
1606 } else {
1607 UpdateMouseKeyEnabled(false);
1608 }
1609
1610 OnIgnoreRepeatClickStateChanged(stateType);
1611 }
1612
OnAccessibleAbilityManagerAudioBalanceChanged(const float audioBalance)1613 void AccessibilityConfig::Impl::OnAccessibleAbilityManagerAudioBalanceChanged(const float audioBalance)
1614 {
1615 HILOG_DEBUG("audioBalance = [%{public}f}", audioBalance);
1616 std::vector<std::shared_ptr<AccessibilityConfigObserver>> observers;
1617 {
1618 std::lock_guard<ffrt::mutex> lock(configObserversMutex_);
1619 if (audioBalance_ == audioBalance) {
1620 return;
1621 }
1622 audioBalance_ = audioBalance;
1623 std::map<CONFIG_ID, std::vector<std::shared_ptr<AccessibilityConfigObserver>>>::iterator it =
1624 configObservers_.find(CONFIG_AUDIO_BALANCE);
1625 if (it == configObservers_.end()) {
1626 return;
1627 }
1628 observers = it->second;
1629 }
1630
1631 NotifyAudioBalanceChanged(observers, audioBalance);
1632 }
1633
OnAccessibleAbilityManagerBrightnessDiscountChanged(const float brightnessDiscount)1634 void AccessibilityConfig::Impl::OnAccessibleAbilityManagerBrightnessDiscountChanged(const float brightnessDiscount)
1635 {
1636 HILOG_DEBUG("brightnessDiscount = [%{public}f}", brightnessDiscount);
1637
1638 std::vector<std::shared_ptr<AccessibilityConfigObserver>> observers;
1639 {
1640 std::lock_guard<ffrt::mutex> lock(configObserversMutex_);
1641 if (brightnessDiscount_ == brightnessDiscount) {
1642 return;
1643 }
1644 brightnessDiscount_ = brightnessDiscount;
1645 std::map<CONFIG_ID, std::vector<std::shared_ptr<AccessibilityConfigObserver>>>::iterator it =
1646 configObservers_.find(CONFIG_BRIGHTNESS_DISCOUNT);
1647 if (it == configObservers_.end()) {
1648 return;
1649 }
1650 observers = it->second;
1651 }
1652
1653 NotifyBrightnessDiscountChanged(observers, brightnessDiscount);
1654 }
1655
OnAccessibleAbilityManagerContentTimeoutChanged(const uint32_t contentTimeout)1656 void AccessibilityConfig::Impl::OnAccessibleAbilityManagerContentTimeoutChanged(const uint32_t contentTimeout)
1657 {
1658 HILOG_DEBUG("contentTimeout = [%{public}u}", contentTimeout);
1659 std::vector<std::shared_ptr<AccessibilityConfigObserver>> observers;
1660 {
1661 std::lock_guard<ffrt::mutex> lock(configObserversMutex_);
1662 if (contentTimeout_ == contentTimeout) {
1663 return;
1664 }
1665 contentTimeout_ = contentTimeout;
1666 std::map<CONFIG_ID, std::vector<std::shared_ptr<AccessibilityConfigObserver>>>::iterator it =
1667 configObservers_.find(CONFIG_CONTENT_TIMEOUT);
1668 if (it == configObservers_.end()) {
1669 return;
1670 }
1671 observers = it->second;
1672 }
1673
1674 NotifyContentTimeoutChanged(observers, contentTimeout);
1675 }
1676
OnAccessibleAbilityManagerDaltonizationColorFilterChanged(const uint32_t filterType)1677 void AccessibilityConfig::Impl::OnAccessibleAbilityManagerDaltonizationColorFilterChanged(const uint32_t filterType)
1678 {
1679 HILOG_DEBUG("filterType = [%{public}u}", filterType);
1680 std::vector<std::shared_ptr<AccessibilityConfigObserver>> observers;
1681 {
1682 std::lock_guard<ffrt::mutex> lock(configObserversMutex_);
1683 if (daltonizationColorFilter_ == filterType) {
1684 HILOG_DEBUG("filterType[%{public}u]", daltonizationColorFilter_);
1685 return;
1686 }
1687 daltonizationColorFilter_ = InvertDaltonizationColorInAtoHos(filterType);
1688 std::map<CONFIG_ID, std::vector<std::shared_ptr<AccessibilityConfigObserver>>>::iterator it =
1689 configObservers_.find(CONFIG_DALTONIZATION_COLOR_FILTER);
1690 if (it == configObservers_.end()) {
1691 return;
1692 }
1693 observers = it->second;
1694 }
1695
1696 NotifyDaltonizationColorFilterChanged(observers, daltonizationColorFilter_);
1697 }
1698
OnAccessibleAbilityManagerMouseAutoClickChanged(const int32_t mouseAutoClick)1699 void AccessibilityConfig::Impl::OnAccessibleAbilityManagerMouseAutoClickChanged(const int32_t mouseAutoClick)
1700 {
1701 HILOG_DEBUG("mouseAutoClick = [%{public}d}", mouseAutoClick);
1702 std::vector<std::shared_ptr<AccessibilityConfigObserver>> observers;
1703 {
1704 std::lock_guard<ffrt::mutex> lock(configObserversMutex_);
1705 if (mouseAutoClick_ == mouseAutoClick) {
1706 return;
1707 }
1708 mouseAutoClick_ = mouseAutoClick;
1709 std::map<CONFIG_ID, std::vector<std::shared_ptr<AccessibilityConfigObserver>>>::iterator it =
1710 configObservers_.find(CONFIG_MOUSE_AUTOCLICK);
1711 if (it == configObservers_.end()) {
1712 return;
1713 }
1714 observers = it->second;
1715 }
1716
1717 NotifyMouseAutoClickChanged(observers, mouseAutoClick);
1718 }
1719
OnAccessibleAbilityManagerShortkeyTargetChanged(const std::string & shortkeyTarget)1720 void AccessibilityConfig::Impl::OnAccessibleAbilityManagerShortkeyTargetChanged(const std::string &shortkeyTarget)
1721 {
1722 HILOG_DEBUG("shortkeyTarget = [%{public}s}", shortkeyTarget.c_str());
1723 std::vector<std::shared_ptr<AccessibilityConfigObserver>> observers;
1724 {
1725 std::lock_guard<ffrt::mutex> lock(configObserversMutex_);
1726 if (shortkeyTarget_.length() > 0 && shortkeyTarget.length() > 0 &&
1727 !std::strcmp(shortkeyTarget_.c_str(), shortkeyTarget.c_str())) {
1728 return;
1729 }
1730 shortkeyTarget_ = shortkeyTarget;
1731 std::map<CONFIG_ID, std::vector<std::shared_ptr<AccessibilityConfigObserver>>>::iterator it =
1732 configObservers_.find(CONFIG_SHORT_KEY_TARGET);
1733 if (it == configObservers_.end()) {
1734 return;
1735 }
1736 observers = it->second;
1737 }
1738
1739 NotifyShortkeyTargetChanged(observers, shortkeyTarget);
1740 }
1741
OnAccessibleAbilityManagerShortkeyMultiTargetChanged(const std::vector<std::string> & shortkeyMultiTarget)1742 void AccessibilityConfig::Impl::OnAccessibleAbilityManagerShortkeyMultiTargetChanged(
1743 const std::vector<std::string> &shortkeyMultiTarget)
1744 {
1745 HILOG_DEBUG("start");
1746 std::vector<std::shared_ptr<AccessibilityConfigObserver>> observers;
1747 {
1748 std::lock_guard<ffrt::mutex> lock(configObserversMutex_);
1749 // need to add, if no change, do not inform
1750 shortkeyMultiTarget_ = shortkeyMultiTarget;
1751 std::map<CONFIG_ID, std::vector<std::shared_ptr<AccessibilityConfigObserver>>>::iterator it =
1752 configObservers_.find(CONFIG_SHORT_KEY_MULTI_TARGET);
1753 if (it == configObservers_.end()) {
1754 HILOG_DEBUG("Cannot find CONFIG_SHORT_KEY_MULTI_TARGET configObserver.");
1755 return;
1756 }
1757 observers = it->second;
1758 }
1759
1760 NotifyShortkeyMultiTargetChanged(observers, shortkeyMultiTarget);
1761 }
1762
OnAccessibleAbilityManagerClickResponseTimeChanged(const uint32_t clickResponseTime)1763 void AccessibilityConfig::Impl::OnAccessibleAbilityManagerClickResponseTimeChanged(const uint32_t clickResponseTime)
1764 {
1765 HILOG_DEBUG("clickResponseTime = [%{public}u}", clickResponseTime);
1766 std::vector<std::shared_ptr<AccessibilityConfigObserver>> observers;
1767 {
1768 std::lock_guard<ffrt::mutex> lock(configObserversMutex_);
1769 if (clickResponseTime_ == clickResponseTime) {
1770 return;
1771 }
1772 clickResponseTime_ = clickResponseTime;
1773 std::map<CONFIG_ID, std::vector<std::shared_ptr<AccessibilityConfigObserver>>>::iterator it =
1774 configObservers_.find(CONIFG_CLICK_RESPONSE_TIME);
1775 if (it == configObservers_.end()) {
1776 return;
1777 }
1778 observers = it->second;
1779 }
1780
1781 NotifyClickResponseTimeChanged(observers, clickResponseTime);
1782 }
1783
OnAccessibleAbilityManagerIgnoreRepeatClickTimeChanged(const uint32_t time)1784 void AccessibilityConfig::Impl::OnAccessibleAbilityManagerIgnoreRepeatClickTimeChanged(const uint32_t time)
1785 {
1786 HILOG_DEBUG("ignoreRepeatClickTime = [%{public}u}", time);
1787 std::vector<std::shared_ptr<AccessibilityConfigObserver>> observers;
1788 {
1789 std::lock_guard<ffrt::mutex> lock(configObserversMutex_);
1790 if (ignoreRepeatClickTime_ == time) {
1791 return;
1792 }
1793 ignoreRepeatClickTime_ = time;
1794 std::map<CONFIG_ID, std::vector<std::shared_ptr<AccessibilityConfigObserver>>>::iterator it =
1795 configObservers_.find(CONFIG_IGNORE_REPEAT_CLICK_TIME);
1796 if (it == configObservers_.end()) {
1797 return;
1798 }
1799 observers = it->second;
1800 }
1801
1802 NotifyIgnoreRepeatClickTimeChanged(observers, time);
1803 }
1804
NotifyImmediately(const CONFIG_ID id,const std::shared_ptr<AccessibilityConfigObserver> & observer)1805 void AccessibilityConfig::Impl::NotifyImmediately(const CONFIG_ID id,
1806 const std::shared_ptr<AccessibilityConfigObserver> &observer)
1807 {
1808 HILOG_DEBUG("NotifyImmediately start.");
1809 ConfigValue configValue;
1810 {
1811 configValue.highContrastText = highContrastText_;
1812 configValue.invertColor = invertColor_;
1813 configValue.animationOff = animationOff_;
1814 configValue.screenMagnifier = screenMagnifier_;
1815 configValue.audioMono = audioMono_;
1816 configValue.mouseKey = mouseKey_;
1817 configValue.shortkey = shortkey_;
1818 configValue.captionState = captionState_;
1819 configValue.contentTimeout = contentTimeout_;
1820 configValue.mouseAutoClick = mouseAutoClick_;
1821 configValue.audioBalance = audioBalance_;
1822 configValue.brightnessDiscount = brightnessDiscount_;
1823 configValue.daltonizationState = daltonizationState_;
1824 if (!configValue.daltonizationState) {
1825 configValue.daltonizationColorFilter = Normal;
1826 } else {
1827 configValue.daltonizationColorFilter = static_cast<DALTONIZATION_TYPE>(daltonizationColorFilter_);
1828 }
1829 configValue.shortkey_target = shortkeyTarget_;
1830 configValue.shortkeyMultiTarget = shortkeyMultiTarget_;
1831 configValue.captionStyle = captionProperty_;
1832 configValue.clickResponseTime = static_cast<CLICK_RESPONSE_TIME>(clickResponseTime_);
1833 configValue.ignoreRepeatClickState = ignoreRepeatClickState_;
1834 configValue.ignoreRepeatClickTime = static_cast<IGNORE_REPEAT_CLICK_TIME>(ignoreRepeatClickTime_);
1835 }
1836 observer->OnConfigChanged(id, configValue);
1837 }
1838
InvertDaltonizationColorInAtoHos(uint32_t filter)1839 uint32_t AccessibilityConfig::Impl::InvertDaltonizationColorInAtoHos(uint32_t filter)
1840 {
1841 if (filter == DISPLAY_DALTONIZER_GREEN) {
1842 return Deuteranomaly;
1843 }
1844 if (filter == DISPLAY_DALTONIZER_RED) {
1845 return Protanomaly;
1846 }
1847 if (filter == DISPLAY_DALTONIZER_BLUE) {
1848 return Tritanomaly;
1849 }
1850 return filter;
1851 }
1852
InitConfigValues()1853 void AccessibilityConfig::Impl::InitConfigValues()
1854 {
1855 Accessibility::AccessibilityConfigData configData;
1856 CaptionProperty caption = {};
1857 CaptionPropertyParcel captionParcel(caption);
1858 if (serviceProxy_ == nullptr) {
1859 return;
1860 }
1861 serviceProxy_->GetAllConfigs(configData, captionParcel);
1862
1863 std::lock_guard<ffrt::mutex> lock(configObserversMutex_);
1864 highContrastText_ = configData.highContrastText_;
1865 invertColor_ = configData.invertColor_;
1866 animationOff_ = configData.animationOff_;
1867 audioMono_ = configData.audioMono_;
1868 mouseKey_ = configData.mouseKey_;
1869 captionState_ = configData.captionState_;
1870 screenMagnifier_ = configData.screenMagnifier_;
1871 shortkey_ = configData.shortkey_;
1872 mouseAutoClick_ = configData.mouseAutoClick_;
1873 daltonizationState_ = configData.daltonizationState_;
1874 daltonizationColorFilter_ = InvertDaltonizationColorInAtoHos(configData.daltonizationColorFilter_);
1875 contentTimeout_ = configData.contentTimeout_;
1876 brightnessDiscount_ = configData.brightnessDiscount_;
1877 audioBalance_ = configData.audioBalance_;
1878 shortkeyTarget_ = configData.shortkeyTarget_;
1879 shortkeyMultiTarget_ = configData.shortkeyMultiTarget_;
1880 clickResponseTime_ = configData.clickResponseTime_;
1881 ignoreRepeatClickTime_ = configData.ignoreRepeatClickTime_;
1882 ignoreRepeatClickState_ = configData.ignoreRepeatClickState_;
1883 captionProperty_ = static_cast<CaptionProperty>(captionParcel);
1884 NotifyDefaultConfigs();
1885 HILOG_DEBUG("ConnectToService Success");
1886 }
1887
NotifyDefaultDaltonizationConfigs()1888 void AccessibilityConfig::Impl::NotifyDefaultDaltonizationConfigs()
1889 {
1890 std::map<CONFIG_ID, std::vector<std::shared_ptr<AccessibilityConfigObserver>>>::iterator it =
1891 configObservers_.find(CONFIG_DALTONIZATION_STATE);
1892 if (it != configObservers_.end()) {
1893 NotifyDaltonizationStateChanged(it->second, daltonizationState_);
1894 }
1895 if ((it = configObservers_.find(CONFIG_DALTONIZATION_COLOR_FILTER)) != configObservers_.end()) {
1896 NotifyDaltonizationColorFilterChanged(it->second, daltonizationColorFilter_);
1897 }
1898 }
1899
NotifyDefaultScreenTouchConfigs()1900 void AccessibilityConfig::Impl::NotifyDefaultScreenTouchConfigs()
1901 {
1902 std::map<CONFIG_ID, std::vector<std::shared_ptr<AccessibilityConfigObserver>>>::iterator it =
1903 configObservers_.find(CONIFG_CLICK_RESPONSE_TIME);
1904 if (it != configObservers_.end()) {
1905 NotifyClickResponseTimeChanged(it->second, clickResponseTime_);
1906 }
1907 if ((it = configObservers_.find(CONFIG_IGNORE_REPEAT_CLICK_STATE)) != configObservers_.end()) {
1908 NotifyIgnoreRepeatClickTimeChanged(it->second, ignoreRepeatClickState_);
1909 }
1910 if ((it = configObservers_.find(CONFIG_IGNORE_REPEAT_CLICK_TIME)) != configObservers_.end()) {
1911 NotifyIgnoreRepeatClickStateChanged(it->second, ignoreRepeatClickTime_);
1912 }
1913 }
1914
NotifyDefaultShortKeyConfigs()1915 void AccessibilityConfig::Impl::NotifyDefaultShortKeyConfigs()
1916 {
1917 std::map<CONFIG_ID, std::vector<std::shared_ptr<AccessibilityConfigObserver>>>::iterator it =
1918 configObservers_.find(CONFIG_SHORT_KEY);
1919 if (it != configObservers_.end()) {
1920 NotifyShortKeyChanged(it->second, shortkey_);
1921 }
1922 if ((it = configObservers_.find(CONFIG_SHORT_KEY_TARGET)) != configObservers_.end()) {
1923 NotifyShortkeyTargetChanged(it->second, shortkeyTarget_);
1924 }
1925 }
1926
NotifyDefaultShortKeyMultiConfigs()1927 void AccessibilityConfig::Impl::NotifyDefaultShortKeyMultiConfigs()
1928 {
1929 std::map<CONFIG_ID, std::vector<std::shared_ptr<AccessibilityConfigObserver>>>::iterator it =
1930 configObservers_.find(CONFIG_SHORT_KEY);
1931 if (it != configObservers_.end()) {
1932 NotifyShortKeyChanged(it->second, shortkey_);
1933 }
1934 if ((it = configObservers_.find(CONFIG_SHORT_KEY_MULTI_TARGET)) != configObservers_.end()) {
1935 NotifyShortkeyMultiTargetChanged(it->second, shortkeyMultiTarget_);
1936 }
1937 }
1938
NotifyDefaultConfigs()1939 void AccessibilityConfig::Impl::NotifyDefaultConfigs()
1940 {
1941 std::map<CONFIG_ID, std::vector<std::shared_ptr<AccessibilityConfigObserver>>>::iterator it =
1942 configObservers_.find(CONFIG_HIGH_CONTRAST_TEXT);
1943 if (it != configObservers_.end()) {
1944 NotifyHighContrastTextChanged(it->second, highContrastText_);
1945 }
1946 if ((it = configObservers_.find(CONFIG_INVERT_COLOR)) != configObservers_.end()) {
1947 NotifyInvertColorChanged(it->second, invertColor_);
1948 }
1949 if ((it = configObservers_.find(CONFIG_CONTENT_TIMEOUT)) != configObservers_.end()) {
1950 NotifyContentTimeoutChanged(it->second, contentTimeout_);
1951 }
1952 if ((it = configObservers_.find(CONFIG_ANIMATION_OFF)) != configObservers_.end()) {
1953 NotifyAnimationOffChanged(it->second, animationOff_);
1954 }
1955 if ((it = configObservers_.find(CONFIG_BRIGHTNESS_DISCOUNT)) != configObservers_.end()) {
1956 NotifyBrightnessDiscountChanged(it->second, brightnessDiscount_);
1957 }
1958 if ((it = configObservers_.find(CONFIG_AUDIO_MONO)) != configObservers_.end()) {
1959 NotifyAudioMonoChanged(it->second, audioMono_);
1960 }
1961 if ((it = configObservers_.find(CONFIG_AUDIO_BALANCE)) != configObservers_.end()) {
1962 NotifyAudioBalanceChanged(it->second, audioBalance_);
1963 }
1964 if ((it = configObservers_.find(CONFIG_MOUSE_KEY)) != configObservers_.end()) {
1965 NotifyMouseKeyChanged(it->second, mouseKey_);
1966 }
1967 if ((it = configObservers_.find(CONFIG_CAPTION_STATE)) != configObservers_.end()) {
1968 NotifyCaptionStateChanged(it->second, captionState_);
1969 }
1970 if ((it = configObservers_.find(CONFIG_CAPTION_STYLE)) != configObservers_.end()) {
1971 NotifyCaptionChanged(it->second, captionProperty_);
1972 }
1973 if ((it = configObservers_.find(CONFIG_SCREEN_MAGNIFICATION)) != configObservers_.end()) {
1974 NotifyScreenMagnificationChanged(it->second, screenMagnifier_);
1975 }
1976 if ((it = configObservers_.find(CONFIG_MOUSE_AUTOCLICK)) != configObservers_.end()) {
1977 NotifyMouseAutoClickChanged(it->second, mouseAutoClick_);
1978 }
1979
1980 NotifyDefaultDaltonizationConfigs();
1981 NotifyDefaultScreenTouchConfigs();
1982 NotifyDefaultShortKeyConfigs();
1983 NotifyDefaultShortKeyMultiConfigs();
1984 }
1985
OnLoadSystemAbilitySuccess(int32_t systemAbilityId,const sptr<IRemoteObject> & remoteObject)1986 void AccessibilityConfig::Impl::AccessibilityLoadCallback::OnLoadSystemAbilitySuccess(int32_t systemAbilityId,
1987 const sptr<IRemoteObject> &remoteObject)
1988 {
1989 HILOG_DEBUG();
1990 if (config_) {
1991 config_->LoadSystemAbilitySuccess(remoteObject);
1992 }
1993 }
1994
OnLoadSystemAbilityFail(int32_t systemAbilityId)1995 void AccessibilityConfig::Impl::AccessibilityLoadCallback::OnLoadSystemAbilityFail(int32_t systemAbilityId)
1996 {
1997 HILOG_DEBUG();
1998 if (config_) {
1999 config_->LoadSystemAbilityFail();
2000 }
2001 }
2002
SetEnhanceConfig(uint8_t * cfg,uint32_t cfgLen)2003 Accessibility::RetError AccessibilityConfig::Impl::SetEnhanceConfig(uint8_t *cfg, uint32_t cfgLen)
2004 {
2005 HILOG_INFO();
2006 std::shared_lock<ffrt::shared_mutex> rLock(rwLock_);
2007 if (cfg == nullptr || cfgLen <= 0) {
2008 HILOG_ERROR("SecCompEnhance cfg info is empty");
2009 return Accessibility::RET_ERR_NULLPTR;
2010 }
2011
2012 if (GetServiceProxy() == nullptr) {
2013 HILOG_ERROR("Failed to get accessibility service");
2014 return Accessibility::RET_ERR_SAMGR;
2015 }
2016 AccessibilitySecCompRawdata rawData;
2017 rawData.size = cfgLen;
2018 rawData.data = cfg;
2019 return static_cast<Accessibility::RetError>(GetServiceProxy()->SetEnhanceConfig(rawData));
2020 }
2021 } // namespace AccessibilityConfig
2022 } // namespace OHOS