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