• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 #ifndef ACCESSIBILITY_CONFIG_IMPL_H
17 #define ACCESSIBILITY_CONFIG_IMPL_H
18 
19 #include "accessibility_config.h"
20 #include "accessibility_enable_ability_lists_observer_stub.h"
21 #include "accessible_ability_manager_caption_observer_stub.h"
22 #include "accessible_ability_manager_config_observer_stub.h"
23 #include "accessible_ability_manager_service_proxy.h"
24 #include "ffrt.h"
25 #include "ffrt_inner.h"
26 #include "event_handler.h"
27 #include "refbase.h"
28 #include "system_ability_load_callback_stub.h"
29 #include "system_ability_status_change_stub.h"
30 #include "rwlock.h"
31 
32 namespace OHOS {
33 namespace AccessibilityConfig {
34 class AccessibilityConfig::Impl {
35 public:
36     Impl();
37     ~Impl();
38 
39     bool InitializeContext();
40 
41     Accessibility::RetError SubscribeConfigObserver(const CONFIG_ID id,
42         const std::shared_ptr<AccessibilityConfigObserver> &observer, const bool retFlag);
43     Accessibility::RetError UnsubscribeConfigObserver(const CONFIG_ID id,
44         const std::shared_ptr<AccessibilityConfigObserver> &observer);
45 
46     Accessibility::RetError SubscribeEnableAbilityListsObserver(
47         const std::shared_ptr<AccessibilityEnableAbilityListsObserver> &observer);
48     Accessibility::RetError UnsubscribeEnableAbilityListsObserver(
49         const std::shared_ptr<AccessibilityEnableAbilityListsObserver> &observer);
50 
51     Accessibility::RetError EnableAbility(const std::string &name, const uint32_t capabilities);
52     Accessibility::RetError DisableAbility(const std::string &name);
53 
54     Accessibility::RetError SetScreenMagnificationState(const bool state);
55     Accessibility::RetError SetShortKeyState(const bool state);
56     Accessibility::RetError SetMouseKeyState(const bool state);
57     Accessibility::RetError SetCaptionsState(const bool state);
58     Accessibility::RetError SetCaptionsProperty(const CaptionProperty &caption);
59     Accessibility::RetError SetMouseAutoClick(const int32_t time);
60     Accessibility::RetError SetShortkeyTarget(const std::string &name);
61     Accessibility::RetError SetShortkeyMultiTarget(const std::vector<std::string> &name);
62     Accessibility::RetError SetHighContrastTextState(bool state);
63     Accessibility::RetError SetInvertColorState(const bool state);
64     Accessibility::RetError SetDaltonizationState(bool state);
65     Accessibility::RetError SetDaltonizationColorFilter(const DALTONIZATION_TYPE type);
66     Accessibility::RetError SetContentTimeout(const uint32_t timer);
67     Accessibility::RetError SetAnimationOffState(const bool state);
68     Accessibility::RetError SetBrightnessDiscount(const float brightness);
69     Accessibility::RetError SetAudioMonoState(const bool state);
70     Accessibility::RetError SetAudioBalance(const float balance);
71     Accessibility::RetError SetClickResponseTime(const CLICK_RESPONSE_TIME time);
72     Accessibility::RetError SetIgnoreRepeatClickState(const bool state);
73     Accessibility::RetError SetIgnoreRepeatClickTime(const IGNORE_REPEAT_CLICK_TIME time);
74 
75     Accessibility::RetError GetScreenMagnificationState(bool &state);
76     Accessibility::RetError GetShortKeyState(bool &state);
77     Accessibility::RetError GetMouseKeyState(bool &state);
78     Accessibility::RetError GetCaptionsState(bool &state);
79     Accessibility::RetError GetCaptionsProperty(CaptionProperty &caption);
80     Accessibility::RetError GetMouseAutoClick(int32_t &time);
81     Accessibility::RetError GetShortkeyTarget(std::string &name);
82     Accessibility::RetError GetShortkeyMultiTarget(std::vector<std::string> &name);
83     Accessibility::RetError GetInvertColorState(bool &state);
84     Accessibility::RetError GetHighContrastTextState(bool &state);
85     Accessibility::RetError GetDaltonizationState(bool &state);
86     Accessibility::RetError GetDaltonizationColorFilter(DALTONIZATION_TYPE &type);
87     Accessibility::RetError GetContentTimeout(uint32_t &timer);
88     Accessibility::RetError GetAnimationOffState(bool &state);
89     Accessibility::RetError GetBrightnessDiscount(float &brightness);
90     Accessibility::RetError GetAudioMonoState(bool &state);
91     Accessibility::RetError GetAudioBalance(float &balance);
92     Accessibility::RetError GetClickResponseTime(CLICK_RESPONSE_TIME &time);
93     Accessibility::RetError GetIgnoreRepeatClickState(bool &state);
94     Accessibility::RetError GetIgnoreRepeatClickTime(IGNORE_REPEAT_CLICK_TIME &time);
95 
96     void ResetService(const wptr<IRemoteObject> &remote);
97     void OnAccessibleAbilityManagerCaptionPropertyChanged(const CaptionProperty &property);
98     void OnAccessibleAbilityManagerConfigStateChanged(const uint32_t stateType);
99     void OnAccessibleAbilityManagerAudioBalanceChanged(const float audioBalance);
100     void OnAccessibleAbilityManagerBrightnessDiscountChanged(const float brightnessDiscount);
101     void OnAccessibleAbilityManagerContentTimeoutChanged(const uint32_t contentTimeout);
102     void OnAccessibleAbilityManagerDaltonizationColorFilterChanged(const uint32_t filterType);
103     void OnAccessibleAbilityManagerMouseAutoClickChanged(const int32_t mouseAutoClick);
104     void OnAccessibleAbilityManagerShortkeyTargetChanged(const std::string &shortkeyTarget);
105     void OnAccessibleAbilityManagerShortkeyMultiTargetChanged(const std::vector<std::string> &shortkeyMultiTarget);
106     void OnAccessibleAbilityManagerClickResponseTimeChanged(const uint32_t clickResponseTime);
107     void OnAccessibleAbilityManagerIgnoreRepeatClickTimeChanged(const uint32_t ignoreRepeatClickTime);
108     void OnAccessibilityEnableAbilityListsChanged();
109     void OnAccessibilityInstallAbilityListsChanged();
110 
SetInitializeFlag(bool flag)111     void SetInitializeFlag(bool flag)
112     {
113         isInitialized_ = flag;
114     }
115 private:
116     class AccessibilityEnableAbilityListsObserverImpl :
117         public Accessibility::AccessibilityEnableAbilityListsObserverStub {
118     public:
AccessibilityEnableAbilityListsObserverImpl(Impl & client)119         explicit AccessibilityEnableAbilityListsObserverImpl(Impl &client)
120             : client_(client) {}
121         ~AccessibilityEnableAbilityListsObserverImpl() = default;
122 
OnAccessibilityEnableAbilityListsChanged()123         virtual void OnAccessibilityEnableAbilityListsChanged() override
124         {
125             if (enableAbilityClientDeleted_ == false) {
126                 client_.OnAccessibilityEnableAbilityListsChanged();
127             }
128         }
129 
OnAccessibilityInstallAbilityListsChanged()130         virtual void OnAccessibilityInstallAbilityListsChanged() override
131         {
132             if (enableAbilityClientDeleted_ == false) {
133                 client_.OnAccessibilityInstallAbilityListsChanged();
134             }
135         }
136 
OnclientDeleted()137         void OnclientDeleted()
138         {
139             enableAbilityClientDeleted_ = true;
140         }
141     private:
142         Impl &client_;
143         std::atomic<bool> enableAbilityClientDeleted_ = false;
144     };
145 
146     class AccessibleAbilityManagerCaptionObserverImpl
147         : public Accessibility::AccessibleAbilityManagerCaptionObserverStub {
148     public:
AccessibleAbilityManagerCaptionObserverImpl(Impl & config_)149         explicit AccessibleAbilityManagerCaptionObserverImpl(Impl &config_)
150             : config_(config_) {}
151         ~AccessibleAbilityManagerCaptionObserverImpl() = default;
152 
OnPropertyChanged(const CaptionProperty & property)153         virtual void OnPropertyChanged(const CaptionProperty &property) override
154         {
155             if (captionClientDeleted_ == false) {
156                 config_.OnAccessibleAbilityManagerCaptionPropertyChanged(property);
157             }
158         }
159 
OnclientDeleted()160         void OnclientDeleted()
161         {
162             captionClientDeleted_ = true;
163         }
164     private:
165         Impl &config_;
166         std::atomic<bool> captionClientDeleted_ = false;
167     };
168 
169     class AccessibilityLoadCallback : public SystemAbilityLoadCallbackStub {
170     public:
AccessibilityLoadCallback(Impl * config)171         explicit AccessibilityLoadCallback(Impl* config) : config_(config) {}
172         ~AccessibilityLoadCallback() = default;
173         void OnLoadSystemAbilitySuccess(int32_t systemAbilityId,
174             const sptr<IRemoteObject> &remoteObject) override;
175         void OnLoadSystemAbilityFail(int32_t systemAbilityId) override;
176     private:
177         Impl* config_ = nullptr;
178     };
179 
180     class AccessibleAbilityManagerConfigObserverImpl
181         : public Accessibility::AccessibleAbilityManagerConfigObserverStub {
182     public:
AccessibleAbilityManagerConfigObserverImpl(Impl & config)183         explicit AccessibleAbilityManagerConfigObserverImpl(Impl &config) : config_(config) {}
184         ~AccessibleAbilityManagerConfigObserverImpl() = default;
185 
OnConfigStateChanged(const uint32_t stateType)186         virtual void OnConfigStateChanged(const uint32_t stateType) override
187         {
188             if (configClientDeleted_ == false) {
189                 config_.OnAccessibleAbilityManagerConfigStateChanged(stateType);
190             }
191         }
OnAudioBalanceChanged(const float audioBalance)192         virtual void OnAudioBalanceChanged(const float audioBalance) override
193         {
194             if (configClientDeleted_ == false) {
195                 config_.OnAccessibleAbilityManagerAudioBalanceChanged(audioBalance);
196             }
197         }
OnBrightnessDiscountChanged(const float brightnessDiscount)198         virtual void OnBrightnessDiscountChanged(const float brightnessDiscount) override
199         {
200             if (configClientDeleted_ == false) {
201                 config_.OnAccessibleAbilityManagerBrightnessDiscountChanged(brightnessDiscount);
202             }
203         }
OnContentTimeoutChanged(const uint32_t contentTimeout)204         virtual void OnContentTimeoutChanged(const uint32_t contentTimeout) override
205         {
206             if (configClientDeleted_ == false) {
207                 config_.OnAccessibleAbilityManagerContentTimeoutChanged(contentTimeout);
208             }
209         }
OnDaltonizationColorFilterChanged(const uint32_t filterType)210         virtual void OnDaltonizationColorFilterChanged(const uint32_t filterType) override
211         {
212             if (configClientDeleted_ == false) {
213                 config_.OnAccessibleAbilityManagerDaltonizationColorFilterChanged(filterType);
214             }
215         }
OnMouseAutoClickChanged(const int32_t mouseAutoClick)216         virtual void OnMouseAutoClickChanged(const int32_t mouseAutoClick) override
217         {
218             if (configClientDeleted_ == false) {
219                 config_.OnAccessibleAbilityManagerMouseAutoClickChanged(mouseAutoClick);
220             }
221         }
OnShortkeyTargetChanged(const std::string & shortkeyTarget)222         virtual void OnShortkeyTargetChanged(const std::string &shortkeyTarget) override
223         {
224             if (configClientDeleted_ == false) {
225                 config_.OnAccessibleAbilityManagerShortkeyTargetChanged(shortkeyTarget);
226             }
227         }
OnShortkeyMultiTargetChanged(const std::vector<std::string> & shortkeyMultiTarget)228         virtual void OnShortkeyMultiTargetChanged(const std::vector<std::string> &shortkeyMultiTarget) override
229         {
230             if (configClientDeleted_ == false) {
231                 config_.OnAccessibleAbilityManagerShortkeyMultiTargetChanged(shortkeyMultiTarget);
232             }
233         }
OnClickResponseTimeChanged(const uint32_t clickResponseTime)234         virtual void OnClickResponseTimeChanged(const uint32_t clickResponseTime) override
235         {
236             if (configClientDeleted_ == false) {
237                 config_.OnAccessibleAbilityManagerClickResponseTimeChanged(clickResponseTime);
238             }
239         }
OnIgnoreRepeatClickTimeChanged(const uint32_t ignoreRepeatClickTime)240         virtual void OnIgnoreRepeatClickTimeChanged(const uint32_t ignoreRepeatClickTime) override
241         {
242             if (configClientDeleted_ == false) {
243                 config_.OnAccessibleAbilityManagerIgnoreRepeatClickTimeChanged(ignoreRepeatClickTime);
244             }
245         }
246 
OnclientDeleted()247         void OnclientDeleted()
248         {
249             configClientDeleted_ = true;
250         }
251 
252     private:
253         Impl &config_;
254         std::atomic<bool> configClientDeleted_ = false;
255     };
256 
257     class DeathRecipient : public IRemoteObject::DeathRecipient {
258     public:
DeathRecipient(Impl & config_)259         explicit DeathRecipient(Impl &config_) : config_(config_) {}
260         ~DeathRecipient() = default;
261         DISALLOW_COPY_AND_MOVE(DeathRecipient);
262 
OnRemoteDied(const wptr<IRemoteObject> & remote)263         void OnRemoteDied(const wptr<IRemoteObject> &remote)
264         {
265             config_.ResetService(remote);
266         }
267     private:
268         Impl &config_;
269     };
270 
271     bool ConnectToService();
272     bool ConnectToServiceAsync();
273 
274     bool RegisterToService();
275     bool InitAccessibilityServiceProxy();
276 
277     bool LoadAccessibilityService();
278     void LoadSystemAbilitySuccess(const sptr<IRemoteObject> &remoteObject);
279     void LoadSystemAbilityFail();
280     sptr<Accessibility::IAccessibleAbilityManagerService> GetServiceProxy();
281 
282     void NotifyCaptionStateChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers,
283         const bool state);
284     void NotifyCaptionChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers,
285         const CaptionProperty &captionProperty);
286     void NotifyScreenMagnificationChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers,
287         const bool state);
288     void NotifyShortKeyChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers,
289         const bool state);
290     void NotifyMouseKeyChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers,
291         const bool state);
292     void NotifyShortkeyTargetChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers,
293         const std::string &shortkey_target);
294     void NotifyShortkeyMultiTargetChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers,
295         const std::vector<std::string> &shortkeyMultiTarget);
296     void NotifyMouseAutoClickChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers,
297         const uint32_t mouseAutoClick);
298     void NotifyAudioBalanceChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers,
299         const float audioBalance);
300     void NotifyBrightnessDiscountChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers,
301         const float brightnessDiscount);
302     void NotifyContentTimeoutChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers,
303         const uint32_t contentTimeout);
304     void NotifyDaltonizationColorFilterChanged(
305         const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers,
306         const uint32_t daltonizationColorFilter);
307     void NotifyAudioMonoChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers,
308         const bool state);
309     void NotifyAnimationOffChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers,
310         const bool state);
311     void NotifyInvertColorChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers,
312         const bool state);
313     void NotifyHighContrastTextChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers,
314         const bool state);
315     void NotifyDaltonizationStateChanged(
316         const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers,
317         const bool state);
318     void NotifyClickResponseTimeChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers,
319         const uint32_t clickResponseTime);
320     void NotifyIgnoreRepeatClickTimeChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers,
321         const uint32_t time);
322     void NotifyIgnoreRepeatClickStateChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers,
323         const bool state);
324 
325     void UpdateScreenMagnificationEnabled(const bool enabled);
326     void UpdateShortKeyEnabled(const bool enabled);
327     void UpdateMouseKeyEnabled(const bool enabled);
328     void UpdateCaptionEnabled(const bool enabled);
329     void UpdateAudioMonoEnabled(const bool enabled);
330     void UpdateAnimationOffEnabled(const bool enabled);
331     void UpdateInvertColorEnabled(const bool enabled);
332     void UpdateHighContrastTextEnabled(const bool enabled);
333     void UpdateDaltonizationStateEnabled(const bool enabled);
334     void UpdateIgnoreRepeatClickStateEnabled(const bool enabled);
335     void NotifyDefaultConfigs();
336     void NotifyDefaultDaltonizationConfigs();
337     void NotifyDefaultScreenTouchConfigs();
338     void NotifyDefaultShortKeyConfigs();
339     void NotifyDefaultShortKeyMultiConfigs();
340     void NotifyImmediately(const CONFIG_ID id, const std::shared_ptr<AccessibilityConfigObserver> &observer);
341     void InitConfigValues();
342     uint32_t InvertDaltonizationColorInAtoHos(uint32_t filter);
343     static void OnParameterChanged(const char *key, const char *value, void *context);
344 
345     void OnIgnoreRepeatClickStateChanged(const uint32_t stateType);
346     bool CheckSaStatus();
347 
348     sptr<Accessibility::IAccessibleAbilityManagerService> serviceProxy_ = nullptr;
349     sptr<AccessibleAbilityManagerCaptionObserverImpl> captionObserver_ = nullptr;
350     sptr<AccessibleAbilityManagerConfigObserverImpl> configObserver_ = nullptr;
351     sptr<AccessibilityEnableAbilityListsObserverImpl> enableAbilityListsObserver_ = nullptr;
352 
353     bool isInitialized_ = false;
354     bool shortkey_ = false;
355     bool highContrastText_ = false;
356     bool screenMagnifier_ = false;
357     bool invertColor_ = false;
358     bool captionState_ = false;
359     bool animationOff_ = false;
360     bool audioMono_ = false;
361     bool mouseKey_ = false;
362     bool daltonizationState_ = false;
363     int32_t mouseAutoClick_ = 0;
364     uint32_t contentTimeout_ = 0;
365     uint32_t daltonizationColorFilter_ = 0;
366     float audioBalance_ = 0.0;
367     float brightnessDiscount_ = 0.0;
368     std::string shortkeyTarget_ = "";
369     uint32_t clickResponseTime_ = 0;
370     uint32_t ignoreRepeatClickTime_ = 0;
371     bool ignoreRepeatClickState_ = false;
372     CaptionProperty captionProperty_ = {};
373 
374     sptr<IRemoteObject::DeathRecipient> deathRecipient_ = nullptr;
375 
376     std::vector<std::string> shortkeyMultiTarget_ {};
377     std::vector<std::shared_ptr<AccessibilityEnableAbilityListsObserver>> enableAbilityListsObservers_;
378     ffrt::mutex enableAbilityListsObserversMutex_;
379     std::map<CONFIG_ID, std::vector<std::shared_ptr<AccessibilityConfigObserver>>> configObservers_;
380     ffrt::mutex configObserversMutex_;
381 
382     // use write-first-rwLock to protect serviceProxy_ to make sure when serviceProxy_ multi-thread used
383     // and one thread which calls interface like SetAudioMonoState timeout,
384     // InitializeContext will get mutex first, in case main-thread block.
385     // InitializeContext always called in main thread
386     Utils::RWLock rwLock_;
387 
388     std::shared_ptr<AppExecFwk::EventRunner> runner_;
389     std::shared_ptr<AppExecFwk::EventHandler> handler_;
390 
391     ffrt::condition_variable proxyConVar_;
392     ffrt::mutex conVarMutex_; // mutex for proxyConVar
393 };
394 } // namespace AccessibilityConfig
395 } // namespace OHOS
396 #endif // ACCESSIBILITY_CONFIG_IMPL_H
397