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