1 /*
2 * Copyright (C) 2025-2025 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 // LCOV_EXCL_START
17 #include "hilog_wrapper.h"
18 #include "magnification_manager.h"
19 #include "accessibility_display_manager.h"
20 #include "accessible_ability_manager_service.h"
21 #include "magnification_menu_manager.h"
22
23 namespace OHOS {
24 namespace Accessibility {
MagnificationManager()25 MagnificationManager::MagnificationManager()
26 {
27 windowProxy_ = MagnificationWindowProxy::GetInstance();
28 }
29
GetWindowMagnificationManager()30 std::shared_ptr<WindowMagnificationManager> MagnificationManager::GetWindowMagnificationManager()
31 {
32 HILOG_DEBUG();
33 currentMode_ = Singleton<AccessibleAbilityManagerService>::GetInstance().GetMagnificationMode();
34 if (windowMagnificationManager_ == nullptr) {
35 windowMagnificationManager_ = std::make_shared<WindowMagnificationManager>(windowProxy_);
36 }
37 return windowMagnificationManager_;
38 }
39
GetFullScreenMagnificationManager()40 std::shared_ptr<FullScreenMagnificationManager> MagnificationManager::GetFullScreenMagnificationManager()
41 {
42 HILOG_DEBUG();
43 currentMode_ = Singleton<AccessibleAbilityManagerService>::GetInstance().GetMagnificationMode();
44 if (fullScreenMagnificationManager_ == nullptr) {
45 fullScreenMagnificationManager_ = std::make_shared<FullScreenMagnificationManager>(windowProxy_);
46 }
47 return fullScreenMagnificationManager_;
48 }
49
GetMenuManager()50 std::shared_ptr<MagnificationMenuManager> MagnificationManager::GetMenuManager()
51 {
52 HILOG_DEBUG();
53 if (menuManager_ == nullptr) {
54 menuManager_ = std::make_shared<MagnificationMenuManager>(windowProxy_);
55 }
56 return menuManager_;
57 }
58
OnMagnificationTypeChanged(uint32_t magnificationType)59 void MagnificationManager::OnMagnificationTypeChanged(uint32_t magnificationType)
60 {
61 HILOG_INFO("magnificationType = %{public}d, currentMode_ = %{public}d", magnificationType, currentMode_);
62 if (windowMagnificationManager_ == nullptr) {
63 HILOG_DEBUG("GetWindowMagnificationManager");
64 GetWindowMagnificationManager();
65 }
66 if (fullScreenMagnificationManager_ == nullptr) {
67 HILOG_DEBUG("GetFullScreenMagnificationManager");
68 GetFullScreenMagnificationManager();
69 }
70
71 if (menuManager_ == nullptr) {
72 HILOG_ERROR("menuManager_ is nullptr.");
73 return;
74 }
75 currentMode_ = Singleton<AccessibleAbilityManagerService>::GetInstance().GetMagnificationMode();
76 menuManager_->SetCurrentType(magnificationType);
77 if (magnificationType == SWITCH_MAGNIFICATION) {
78 if (windowMagnificationManager_ != nullptr && windowMagnificationManager_->IsMagnificationWindowShow()) {
79 menuManager_->DisableMenuWindow();
80 menuManager_->ShowMenuWindow(currentMode_);
81 return;
82 }
83
84 if (fullScreenMagnificationManager_ != nullptr &&
85 fullScreenMagnificationManager_->IsMagnificationWindowShow()) {
86 menuManager_->DisableMenuWindow();
87 menuManager_->ShowMenuWindow(currentMode_);
88 return;
89 }
90 }
91
92 menuManager_->DisableMenuWindow();
93
94 HILOG_INFO("magnificationType = %{public}d, currentMode_ = %{public}d", magnificationType, currentMode_);
95 if (currentMode_ == magnificationType) {
96 return;
97 }
98
99 OnModeChanged(magnificationType);
100 }
101
OnModeChanged(uint32_t mode)102 void MagnificationManager::OnModeChanged(uint32_t mode)
103 {
104 HILOG_INFO("mode = %{public}d.", mode);
105 if (windowMagnificationManager_ == nullptr) {
106 HILOG_DEBUG("GetWindowMagnificationManager");
107 GetWindowMagnificationManager();
108 }
109 if (fullScreenMagnificationManager_ == nullptr) {
110 HILOG_DEBUG("GetFullScreenMagnificationManager");
111 GetFullScreenMagnificationManager();
112 }
113
114 if (mode != FULL_SCREEN_MAGNIFICATION && mode != WINDOW_MAGNIFICATION) {
115 HILOG_ERROR("invalid mode = %{public}d.", mode);
116 return;
117 }
118
119 auto interceptor = AccessibilityInputInterceptor::GetInstance();
120 if (interceptor == nullptr) {
121 HILOG_ERROR("interceptor is nullptr.");
122 return;
123 }
124 bool needShow = false;
125 PointerPos pos = {0, 0};
126 if (mode == WINDOW_MAGNIFICATION) {
127 HILOG_INFO("disable full screen magnification.");
128 if (fullScreenMagnificationManager_ != nullptr) {
129 needShow = fullScreenMagnificationManager_->IsMagnificationWindowShow();
130 pos = fullScreenMagnificationManager_->GetSourceCenter();
131 fullScreenMagnificationManager_->DisableMagnification();
132 }
133 if (windowMagnificationManager_ != nullptr && needShow) {
134 windowMagnificationManager_->ShowWindowMagnificationWithPosition(pos);
135 Singleton<AccessibleAbilityManagerService>::GetInstance().AnnouncedForMagnification(
136 AnnounceType::ANNOUNCE_SWITCH_WINDOW);
137 }
138 } else {
139 HILOG_INFO("disable window magnification.");
140 if (windowMagnificationManager_ != nullptr) {
141 needShow = windowMagnificationManager_->IsMagnificationWindowShow();
142 pos = windowMagnificationManager_->GetSourceCenter();
143 windowMagnificationManager_->DisableWindowMagnification();
144 }
145 if (fullScreenMagnificationManager_ != nullptr && needShow) {
146 fullScreenMagnificationManager_->ShowMagnificationWithPosition(pos);
147 Singleton<AccessibleAbilityManagerService>::GetInstance().AnnouncedForMagnification(
148 AnnounceType::ANNOUNCE_SWITCH_FULL_SCREEN);
149 }
150 }
151 Singleton<AccessibleAbilityManagerService>::GetInstance().SetMagnificationMode(static_cast<int32_t>(mode));
152 currentMode_ = mode;
153 if (needShow) {
154 interceptor->StartMagnificationInteract(mode);
155 }
156 Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateInputFilter();
157 }
158
DisableMagnification()159 void MagnificationManager::DisableMagnification()
160 {
161 HILOG_INFO();
162 auto interceptor = AccessibilityInputInterceptor::GetInstance();
163 if (menuManager_ != nullptr) {
164 menuManager_->DisableMenuWindow();
165 }
166 if (windowMagnificationManager_ != nullptr && windowMagnificationManager_->IsMagnificationWindowShow()) {
167 HILOG_INFO("disable window");
168 windowMagnificationManager_->DisableWindowMagnification();
169 interceptor->DisableGesture(WINDOW_MAGNIFICATION);
170 }
171 if (fullScreenMagnificationManager_ != nullptr && fullScreenMagnificationManager_->IsMagnificationWindowShow()) {
172 HILOG_INFO("disable full");
173 fullScreenMagnificationManager_->DisableMagnification();
174 interceptor->DisableGesture(FULL_SCREEN_MAGNIFICATION);
175 }
176 }
177
TriggerMagnification(uint32_t type,uint32_t mode)178 void MagnificationManager::TriggerMagnification(uint32_t type, uint32_t mode)
179 {
180 HILOG_INFO("type = %{public}d, mode = %{public}d", type, mode);
181 if (mode == WINDOW_MAGNIFICATION) {
182 if (windowMagnificationManager_ != nullptr) {
183 windowMagnificationManager_->ShowWindowMagnification();
184 }
185 }
186
187 if (mode == FULL_SCREEN_MAGNIFICATION) {
188 if (fullScreenMagnificationManager_ != nullptr) {
189 fullScreenMagnificationManager_->ShowMagnification();
190 }
191 }
192
193 if (type == SWITCH_MAGNIFICATION && menuManager_ != nullptr) {
194 menuManager_->ShowMenuWindow(mode);
195 }
196
197 auto interceptor = AccessibilityInputInterceptor::GetInstance();
198 interceptor->EnableGesture(mode);
199 }
200
GetMagnificationState()201 bool MagnificationManager::GetMagnificationState()
202 {
203 if (currentMode_ == WINDOW_MAGNIFICATION && windowMagnificationManager_ != nullptr) {
204 return windowMagnificationManager_->IsMagnificationWindowShow();
205 }
206
207 if (currentMode_ == FULL_SCREEN_MAGNIFICATION && fullScreenMagnificationManager_ != nullptr) {
208 return fullScreenMagnificationManager_->IsMagnificationWindowShow();
209 }
210 return false;
211 }
212
RefreshWindowParam(RotationType type)213 void MagnificationManager::RefreshWindowParam(RotationType type)
214 {
215 HILOG_DEBUG();
216 if (currentMode_ == WINDOW_MAGNIFICATION && windowMagnificationManager_ != nullptr) {
217 windowMagnificationManager_->RefreshWindowParam(type);
218 }
219
220 if (currentMode_ == FULL_SCREEN_MAGNIFICATION && fullScreenMagnificationManager_ != nullptr) {
221 fullScreenMagnificationManager_->RefreshWindowParam(type);
222 }
223
224 if (menuManager_ != nullptr) {
225 menuManager_->RefreshWindowParam();
226 }
227 }
228
FollowFocuseElement(int32_t centerX,int32_t centerY)229 void MagnificationManager::FollowFocuseElement(int32_t centerX, int32_t centerY)
230 {
231 HILOG_INFO();
232 if (currentMode_ == WINDOW_MAGNIFICATION && windowMagnificationManager_ != nullptr) {
233 if (windowMagnificationManager_->IsMagnificationWindowShow()) {
234 windowMagnificationManager_->FollowFocuseElement(centerX, centerY);
235 }
236 }
237
238 if (currentMode_ == FULL_SCREEN_MAGNIFICATION && fullScreenMagnificationManager_ != nullptr) {
239 if (fullScreenMagnificationManager_->IsMagnificationWindowShow()) {
240 fullScreenMagnificationManager_->FollowFocuseElement(centerX, centerY);
241 }
242 }
243 }
244 } // namespace Accessibility
245 } // namespace OHOS
246 // LCOV_EXCL_STOP