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