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() = default;
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             client_.OnAccessibilityEnableAbilityListsChanged();
126         }
127 
OnAccessibilityInstallAbilityListsChanged()128         virtual void OnAccessibilityInstallAbilityListsChanged() override
129         {
130             client_.OnAccessibilityInstallAbilityListsChanged();
131         }
132     private:
133         Impl &client_;
134     };
135 
136     class AccessibleAbilityManagerCaptionObserverImpl
137         : public Accessibility::AccessibleAbilityManagerCaptionObserverStub {
138     public:
AccessibleAbilityManagerCaptionObserverImpl(Impl & config_)139         explicit AccessibleAbilityManagerCaptionObserverImpl(Impl &config_)
140             : config_(config_) {}
141         ~AccessibleAbilityManagerCaptionObserverImpl() = default;
142 
OnPropertyChanged(const CaptionProperty & property)143         virtual void OnPropertyChanged(const CaptionProperty &property) override
144         {
145             config_.OnAccessibleAbilityManagerCaptionPropertyChanged(property);
146         }
147     private:
148         Impl &config_;
149     };
150 
151     class AccessibilityLoadCallback : public SystemAbilityLoadCallbackStub {
152     public:
AccessibilityLoadCallback(Impl * config)153         explicit AccessibilityLoadCallback(Impl* config) : config_(config) {}
154         ~AccessibilityLoadCallback() = default;
155         void OnLoadSystemAbilitySuccess(int32_t systemAbilityId,
156             const sptr<IRemoteObject> &remoteObject) override;
157         void OnLoadSystemAbilityFail(int32_t systemAbilityId) override;
158     private:
159         Impl* config_ = nullptr;
160     };
161 
162     class AccessibleAbilityManagerConfigObserverImpl
163         : public Accessibility::AccessibleAbilityManagerConfigObserverStub {
164     public:
AccessibleAbilityManagerConfigObserverImpl(Impl & config)165         explicit AccessibleAbilityManagerConfigObserverImpl(Impl &config) : config_(config) {}
166         ~AccessibleAbilityManagerConfigObserverImpl() = default;
167 
OnConfigStateChanged(const uint32_t stateType)168         virtual void OnConfigStateChanged(const uint32_t stateType) override
169         {
170             config_.OnAccessibleAbilityManagerConfigStateChanged(stateType);
171         }
OnAudioBalanceChanged(const float audioBalance)172         virtual void OnAudioBalanceChanged(const float audioBalance) override
173         {
174             config_.OnAccessibleAbilityManagerAudioBalanceChanged(audioBalance);
175         }
OnBrightnessDiscountChanged(const float brightnessDiscount)176         virtual void OnBrightnessDiscountChanged(const float brightnessDiscount) override
177         {
178             config_.OnAccessibleAbilityManagerBrightnessDiscountChanged(brightnessDiscount);
179         }
OnContentTimeoutChanged(const uint32_t contentTimeout)180         virtual void OnContentTimeoutChanged(const uint32_t contentTimeout) override
181         {
182             config_.OnAccessibleAbilityManagerContentTimeoutChanged(contentTimeout);
183         }
OnDaltonizationColorFilterChanged(const uint32_t filterType)184         virtual void OnDaltonizationColorFilterChanged(const uint32_t filterType) override
185         {
186             config_.OnAccessibleAbilityManagerDaltonizationColorFilterChanged(filterType);
187         }
OnMouseAutoClickChanged(const int32_t mouseAutoClick)188         virtual void OnMouseAutoClickChanged(const int32_t mouseAutoClick) override
189         {
190             config_.OnAccessibleAbilityManagerMouseAutoClickChanged(mouseAutoClick);
191         }
OnShortkeyTargetChanged(const std::string & shortkeyTarget)192         virtual void OnShortkeyTargetChanged(const std::string &shortkeyTarget) override
193         {
194             config_.OnAccessibleAbilityManagerShortkeyTargetChanged(shortkeyTarget);
195         }
OnShortkeyMultiTargetChanged(const std::vector<std::string> & shortkeyMultiTarget)196         virtual void OnShortkeyMultiTargetChanged(const std::vector<std::string> &shortkeyMultiTarget) override
197         {
198             config_.OnAccessibleAbilityManagerShortkeyMultiTargetChanged(shortkeyMultiTarget);
199         }
OnClickResponseTimeChanged(const uint32_t clickResponseTime)200         virtual void OnClickResponseTimeChanged(const uint32_t clickResponseTime) override
201         {
202             config_.OnAccessibleAbilityManagerClickResponseTimeChanged(clickResponseTime);
203         }
OnIgnoreRepeatClickTimeChanged(const uint32_t ignoreRepeatClickTime)204         virtual void OnIgnoreRepeatClickTimeChanged(const uint32_t ignoreRepeatClickTime) override
205         {
206             config_.OnAccessibleAbilityManagerIgnoreRepeatClickTimeChanged(ignoreRepeatClickTime);
207         }
208 
209     private:
210         Impl &config_;
211     };
212 
213     class DeathRecipient : public IRemoteObject::DeathRecipient {
214     public:
DeathRecipient(Impl & config_)215         explicit DeathRecipient(Impl &config_) : config_(config_) {}
216         ~DeathRecipient() = default;
217         DISALLOW_COPY_AND_MOVE(DeathRecipient);
218 
OnRemoteDied(const wptr<IRemoteObject> & remote)219         void OnRemoteDied(const wptr<IRemoteObject> &remote)
220         {
221             config_.ResetService(remote);
222         }
223     private:
224         Impl &config_;
225     };
226 
227     bool ConnectToService();
228     bool ConnectToServiceAsync();
229 
230     bool RegisterToService();
231     bool InitAccessibilityServiceProxy();
232 
233     bool LoadAccessibilityService();
234     void LoadSystemAbilitySuccess(const sptr<IRemoteObject> &remoteObject);
235     void LoadSystemAbilityFail();
236     sptr<Accessibility::IAccessibleAbilityManagerService> GetServiceProxy();
237 
238     void NotifyCaptionStateChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers,
239         const bool state);
240     void NotifyCaptionChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers,
241         const CaptionProperty &captionProperty);
242     void NotifyScreenMagnificationChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers,
243         const bool state);
244     void NotifyShortKeyChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers,
245         const bool state);
246     void NotifyMouseKeyChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers,
247         const bool state);
248     void NotifyShortkeyTargetChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers,
249         const std::string &shortkey_target);
250     void NotifyShortkeyMultiTargetChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers,
251         const std::vector<std::string> &shortkeyMultiTarget);
252     void NotifyMouseAutoClickChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers,
253         const uint32_t mouseAutoClick);
254     void NotifyAudioBalanceChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers,
255         const float audioBalance);
256     void NotifyBrightnessDiscountChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers,
257         const float brightnessDiscount);
258     void NotifyContentTimeoutChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers,
259         const uint32_t contentTimeout);
260     void NotifyDaltonizationColorFilterChanged(
261         const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers,
262         const uint32_t daltonizationColorFilter);
263     void NotifyAudioMonoChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers,
264         const bool state);
265     void NotifyAnimationOffChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers,
266         const bool state);
267     void NotifyInvertColorChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers,
268         const bool state);
269     void NotifyHighContrastTextChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers,
270         const bool state);
271     void NotifyDaltonizationStateChanged(
272         const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers,
273         const bool state);
274     void NotifyClickResponseTimeChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers,
275         const uint32_t clickResponseTime);
276     void NotifyIgnoreRepeatClickTimeChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers,
277         const uint32_t time);
278     void NotifyIgnoreRepeatClickStateChanged(const std::vector<std::shared_ptr<AccessibilityConfigObserver>> &observers,
279         const bool state);
280 
281     void UpdateScreenMagnificationEnabled(const bool enabled);
282     void UpdateShortKeyEnabled(const bool enabled);
283     void UpdateMouseKeyEnabled(const bool enabled);
284     void UpdateCaptionEnabled(const bool enabled);
285     void UpdateAudioMonoEnabled(const bool enabled);
286     void UpdateAnimationOffEnabled(const bool enabled);
287     void UpdateInvertColorEnabled(const bool enabled);
288     void UpdateHighContrastTextEnabled(const bool enabled);
289     void UpdateDaltonizationStateEnabled(const bool enabled);
290     void UpdateIgnoreRepeatClickStateEnabled(const bool enabled);
291     void NotifyDefaultConfigs();
292     void NotifyDefaultDaltonizationConfigs();
293     void NotifyDefaultScreenTouchConfigs();
294     void NotifyDefaultShortKeyConfigs();
295     void NotifyDefaultShortKeyMultiConfigs();
296     void NotifyImmediately(const CONFIG_ID id, const std::shared_ptr<AccessibilityConfigObserver> &observer);
297     void InitConfigValues();
298     uint32_t InvertDaltonizationColorInAtoHos(uint32_t filter);
299     static void OnParameterChanged(const char *key, const char *value, void *context);
300 
301     void OnIgnoreRepeatClickStateChanged(const uint32_t stateType);
302     bool CheckSaStatus();
303 
304     sptr<Accessibility::IAccessibleAbilityManagerService> serviceProxy_ = nullptr;
305     sptr<AccessibleAbilityManagerCaptionObserverImpl> captionObserver_ = nullptr;
306     sptr<AccessibleAbilityManagerConfigObserverImpl> configObserver_ = nullptr;
307     sptr<AccessibilityEnableAbilityListsObserverImpl> enableAbilityListsObserver_ = nullptr;
308 
309     bool isInitialized_ = false;
310     bool shortkey_ = false;
311     bool highContrastText_ = false;
312     bool screenMagnifier_ = false;
313     bool invertColor_ = false;
314     bool captionState_ = false;
315     bool animationOff_ = false;
316     bool audioMono_ = false;
317     bool mouseKey_ = false;
318     bool daltonizationState_ = false;
319     int32_t mouseAutoClick_ = 0;
320     uint32_t contentTimeout_ = 0;
321     uint32_t daltonizationColorFilter_ = 0;
322     float audioBalance_ = 0.0;
323     float brightnessDiscount_ = 0.0;
324     std::string shortkeyTarget_ = "";
325     uint32_t clickResponseTime_ = 0;
326     uint32_t ignoreRepeatClickTime_ = 0;
327     bool ignoreRepeatClickState_ = false;
328     CaptionProperty captionProperty_ = {};
329 
330     sptr<IRemoteObject::DeathRecipient> deathRecipient_ = nullptr;
331 
332     std::vector<std::string> shortkeyMultiTarget_ {};
333     std::vector<std::shared_ptr<AccessibilityEnableAbilityListsObserver>> enableAbilityListsObservers_;
334     ffrt::mutex enableAbilityListsObserversMutex_;
335     std::map<CONFIG_ID, std::vector<std::shared_ptr<AccessibilityConfigObserver>>> configObservers_;
336     ffrt::mutex configObserversMutex_;
337 
338     // use write-first-rwLock to protect serviceProxy_ to make sure when serviceProxy_ multi-thread used
339     // and one thread which calls interface like SetAudioMonoState timeout,
340     // InitializeContext will get mutex first, in case main-thread block.
341     // InitializeContext always called in main thread
342     Utils::RWLock rwLock_;
343 
344     std::shared_ptr<AppExecFwk::EventRunner> runner_;
345     std::shared_ptr<AppExecFwk::EventHandler> handler_;
346 
347     ffrt::condition_variable proxyConVar_;
348     ffrt::mutex conVarMutex_; // mutex for proxyConVar
349 };
350 } // namespace AccessibilityConfig
351 } // namespace OHOS
352 #endif // ACCESSIBILITY_CONFIG_IMPL_H
353