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