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 #include "amsstabilityb1.h"
17 #include "accessibility_ability_info.h"
18 #include "accessibility_system_ability_client.h"
19 #include "hilog_wrapper.h"
20 #include "refbase.h"
21
22 using namespace OHOS::Accessibility;
23
24 namespace OHOS {
25 namespace AppExecFwk {
26 const int TESTWINDOWID = 0;
27 const int TESTUSERID = 0;
28 const int STATETYPE = 1;
29 static const int32_t CHILD_ID = 2;
30
OnAbilityConnected()31 void AccessibleAbilityListenerTest::OnAbilityConnected()
32 {
33 HILOG_INFO("##############AamsStAbilityB1: Accessible application is connected.");
34 AbilityContext context;
35 auto eventType = Accessibility::EventType::TYPE_VIEW_ACCESSIBILITY_FOCUSED_EVENT;
36 int componentId = 1;
37 AccessibilitySystemAbilityClient::GetInstance(context)->SendEvent(eventType, componentId);
38 }
39
OnAccessibilityEvent(const AccessibilityEventInfo & eventInfo)40 void AccessibleAbilityListenerTest::OnAccessibilityEvent(const AccessibilityEventInfo& eventInfo)
41 {
42 HILOG_INFO("##############AamsStAbilityB1: An Accessibility event is received and eventType is %{public}d",
43 eventInfo.GetEventType());
44 std::optional<AccessibilityElementInfo> elementInfo;
45 Accessibility::AccessibleAbility::GetInstance().GetRootElementInfo(elementInfo);
46 if (elementInfo.has_value()) {
47 HILOG_INFO("elementInfo has value.");
48 } else {
49 HILOG_ERROR("elementInfo has no value.");
50 }
51 }
52
OnGesture(uint32_t gestureId)53 void AccessibleAbilityListenerTest::OnGesture(uint32_t gestureId)
54 {
55 HILOG_INFO("##############AamsStAbilityB1: A gesture is received and gestureId is %{public}u.", gestureId);
56 }
57
OnInterrupt()58 void AccessibleAbilityListenerTest::OnInterrupt()
59 {
60 HILOG_INFO("##############AamsStAbilityB1: Accessible application is on interrupt.");
61 }
62
OnKeyPressEvent(const MMI::KeyEvent & keyEvent)63 bool AccessibleAbilityListenerTest::OnKeyPressEvent(const MMI::KeyEvent& keyEvent)
64 {
65 HILOG_INFO("##############AamsStAbilityB1: A key press event is received");
66 return true;
67 }
68
OnStart(const Want & want)69 void AamsStAbilityB1::OnStart(const Want &want)
70 {
71 GetWantInfo(want);
72
73 HILOG_INFO("##############AamsStAbilityB1::onStart");
74 RegisterInteractionOperation();
75 AbilityContext context;
76 auto eventType = Accessibility::EventType::TYPE_VIEW_ACCESSIBILITY_FOCUSED_EVENT;
77 int componentId = 1;
78 AccessibilitySystemAbilityClient::GetInstance(context)->SendEvent(eventType, componentId);
79 }
80
OnForeground(const Want & want)81 void AamsStAbilityB1::OnForeground(const Want &want)
82 {
83 GetWantInfo(want);
84
85 HILOG_INFO("AamsStAbilityB1::OnForeground");
86 Ability::OnForeground(want);
87 }
88
OnNewWant(const Want & want)89 void AamsStAbilityB1::OnNewWant(const Want &want)
90 {
91 GetWantInfo(want);
92
93 HILOG_INFO("AamsStAbilityB1::OnNewWant");
94 Ability::OnNewWant(want);
95 }
96
OnStop()97 void AamsStAbilityB1::OnStop()
98 {
99 HILOG_INFO("AamsStAbilityB1::onStop");
100 Ability::OnStop();
101 }
102
OnActive()103 void AamsStAbilityB1::OnActive()
104 {
105 HILOG_INFO("AamsStAbilityB1::OnActive");
106 Ability::OnActive();
107 if (std::string::npos != shouldReturn.find(GetAbilityName())) {
108 TerminateAbility();
109 }
110 Clear();
111 }
112
OnInactive()113 void AamsStAbilityB1::OnInactive()
114 {
115 HILOG_INFO("AamsStAbilityB1::OnInactive");
116 Ability::OnInactive();
117 }
118
OnBackground()119 void AamsStAbilityB1::OnBackground()
120 {
121 HILOG_INFO("AamsStAbilityB1::OnBackground");
122 Ability::OnBackground();
123 }
124
Clear()125 void AamsStAbilityB1::Clear()
126 {
127 shouldReturn = "";
128 targetBundle = "";
129 targetAbility = "";
130 }
131
GetWantInfo(const Want & want)132 void AamsStAbilityB1::GetWantInfo(const Want &want)
133 {
134 Want mWant(want);
135 shouldReturn = mWant.GetStringParam("shouldReturn");
136 targetBundle = mWant.GetStringParam("targetBundle");
137 targetAbility = mWant.GetStringParam("targetAbility");
138 }
139
Interrupt()140 void AamsStAbilityB1::Interrupt()
141 {
142 HILOG_INFO("AamsStAbilityB1::Interrupt");
143 AbilityContext context;
144 Accessibility::AccessibilitySystemAbilityClient::GetInstance(context)->Interrupt();
145 }
146
RegisterInteractionOperation()147 void AamsStAbilityB1::RegisterInteractionOperation()
148 {
149 HILOG_INFO("AamsStAbilityB1::RegisterInteractionOperation");
150 AbilityContext context;
151 int windowId = 0;
152 int userId = TESTUSERID;
153 std::shared_ptr<AccessibilityInteractionOperationTest> interactionOperation =
154 std::make_shared<AccessibilityInteractionOperationTest>();
155 Accessibility::AccessibilitySystemAbilityClient::GetInstance(context)->RegisterInteractionOperation(
156 windowId, interactionOperation, userId);
157 }
158
DeregisterInteractionOperation()159 void AamsStAbilityB1::DeregisterInteractionOperation()
160 {
161 HILOG_INFO("AamsStAbilityB1::DeregisterInteractionOperation");
162 AbilityContext context;
163 int windowId = TESTWINDOWID;
164 Accessibility::AccessibilitySystemAbilityClient::GetInstance(context)->DeregisterInteractionOperation(windowId);
165 }
166
GetAbilityList()167 void AamsStAbilityB1::GetAbilityList()
168 {
169 HILOG_INFO("AamsStAbilityB1::GetAbilityList");
170 AbilityContext context;
171 uint32_t accessibilityAbilityTypes = Accessibility::AccessibilityAbilityTypes::ACCESSIBILITY_ABILITY_TYPE_SPOKEN;
172 auto stateType = Accessibility::AbilityStateType::ABILITY_STATE_ENABLE;
173 AccessibilitySystemAbilityClient::GetInstance(context)->GetAbilityList(accessibilityAbilityTypes, stateType);
174 }
175
GetSuggestedInterval()176 void AamsStAbilityB1::GetSuggestedInterval()
177 {
178 HILOG_INFO("AamsStAbilityB1::GetSuggestedInterval");
179 AbilityContext context;
180 int timeout = 1;
181 int contentType = 1;
182 AccessibilitySystemAbilityClient::GetInstance(context)->GetSuggestedInterval(timeout, contentType);
183 }
184
SendEventWithType()185 void AamsStAbilityB1::SendEventWithType()
186 {
187 HILOG_INFO("##############AamsStAbilityB1::SendEventWithType");
188 AbilityContext context;
189 auto eventType = Accessibility::EventType::TYPE_VIEW_ACCESSIBILITY_FOCUSED_EVENT;
190 int componentId = 1;
191 AccessibilitySystemAbilityClient::GetInstance(context)->SendEvent(eventType, componentId);
192 }
193
SendEvent()194 void AamsStAbilityB1::SendEvent()
195 {
196 HILOG_INFO("AamsStAbilityB1::SendEvent");
197 AbilityContext context;
198 AccessibilityEventInfo eventInfo;
199 AccessibilitySystemAbilityClient::GetInstance(context)->SendEvent(eventInfo);
200 }
201
SubscribeStateObserver()202 void AamsStAbilityB1::SubscribeStateObserver()
203 {
204 HILOG_INFO("AamsStAbilityB1::SubscribeStateObserver");
205 AbilityContext context;
206 auto eventType = Accessibility::EventType::TYPE_VIEW_ACCESSIBILITY_FOCUSED_EVENT;
207 std::shared_ptr<AccessibilityStateObserver> stateObserver =
208 std::make_shared<AccessibilityStateObserverTest>();
209
210 AccessibilitySystemAbilityClient::GetInstance(context)->SubscribeStateObserver(stateObserver, eventType);
211 }
212
UnsubscribeStateObserver()213 void AamsStAbilityB1::UnsubscribeStateObserver()
214 {
215 HILOG_INFO("AamsStAbilityB1::UnsubscribeStateObserver");
216 AbilityContext context;
217 auto eventType = Accessibility::EventType::TYPE_VIEW_ACCESSIBILITY_FOCUSED_EVENT;
218 std::shared_ptr<AccessibilityStateObserver> stateObserver =
219 std::make_shared<AccessibilityStateObserverTest>();
220
221 AccessibilitySystemAbilityClient::GetInstance(context)->UnsubscribeStateObserver(stateObserver, eventType);
222 }
223
UnsubscribeStateObserverEventType()224 void AamsStAbilityB1::UnsubscribeStateObserverEventType()
225 {
226 HILOG_INFO("AamsStAbilityB1::UnsubscribeStateObserverEventType");
227 AbilityContext context;
228 std::shared_ptr<AccessibilityStateObserver> stateObserver =
229 std::make_shared<AccessibilityStateObserverTest>();
230 AccessibilitySystemAbilityClient::GetInstance(context)->UnsubscribeStateObserver(stateObserver);
231 }
232
RegisterListenerToAA()233 void AamsStAbilityB1::RegisterListenerToAA()
234 {
235 HILOG_INFO("##############AamsStAbilityB1:: start");
236 listener_ = std::make_shared<AccessibleAbilityListenerTest>();
237 if (!listener_) {
238 HILOG_ERROR("##############listener_ is nullptr.");
239 return;
240 }
241 Accessibility::AccessibleAbility::GetInstance().RegisterListener(listener_);
242 }
243
ConnectToAAMS()244 void AamsStAbilityB1::ConnectToAAMS()
245 {
246 HILOG_INFO("##############AamsStAbilityB1:: start");
247 Accessibility::AccessibleAbility::GetInstance().ConnectToAAMS();
248 }
249
GetRootElementInfo()250 void AamsStAbilityB1::GetRootElementInfo()
251 {
252 HILOG_INFO("##############AamsStAbilityB1:: start");
253 std::optional<AccessibilityElementInfo> elementInfo;
254 Accessibility::AccessibleAbility::GetInstance().GetRootElementInfo(elementInfo);
255
256 if (elementInfo.has_value()) {
257 HILOG_INFO("elementInfo has value.");
258 } else {
259 HILOG_INFO("elementInfo has no value.");
260 }
261 }
262
SearchElementInfoByAccessibilityId(const long elementId,const int requestId,Accessibility::AccessibilityInteractionOperationCallback & callback,const int mode)263 void AccessibilityInteractionOperationTest::SearchElementInfoByAccessibilityId(const long elementId,
264 const int requestId, Accessibility::AccessibilityInteractionOperationCallback &callback, const int mode)
265 {
266 HILOG_INFO("##############AamsStAbilityB1:: start");
267 AccessibilityElementInfo info;
268 info.SetBundleName("testapp_B1");
269 info.SetWindowId(0);
270 info.SetCheckable(true);
271 info.SetHint("testapp_B1_findFocus");
272 info.AddChild(CHILD_ID);
273 std::list<AccessibilityElementInfo> infos;
274 infos.push_back(info);
275 callback.SetSearchElementInfoByAccessibilityIdResult(infos, requestId);
276 }
277
SearchElementInfosByText(const long elementId,const std::string & text,const int requestId,Accessibility::AccessibilityInteractionOperationCallback & callback)278 void AccessibilityInteractionOperationTest::SearchElementInfosByText(const long elementId, const std::string &text,
279 const int requestId, Accessibility::AccessibilityInteractionOperationCallback &callback)
280 {
281 HILOG_INFO("##############AamsStAbilityB1:: start");
282 AccessibilityElementInfo info;
283 info.SetBundleName("fang-ch");
284 info.SetWindowId(0);
285 info.SetComponentType("2021年");
286 info.SetCheckable(true);
287 info.SetHint("testapp_B1_findFocus");
288 std::list<AccessibilityElementInfo> infos;
289 infos.push_back(info);
290 callback.SetSearchElementInfoByTextResult(infos, requestId);
291 HILOG_INFO("##############AamsStAbilityB1::=======SearchElementInfosByText::=======success=======");
292 }
293
FindFocusedElementInfo(const long elementId,const int focusType,const int requestId,Accessibility::AccessibilityInteractionOperationCallback & callback)294 void AccessibilityInteractionOperationTest::FindFocusedElementInfo(const long elementId, const int focusType,
295 const int requestId, Accessibility::AccessibilityInteractionOperationCallback &callback)
296 {
297 HILOG_INFO("##############AamsStAbilityB1:: start");
298 AccessibilityElementInfo info;
299 info.SetWindowId(0);
300 info.SetBundleName("testapp_B1_findFocus");
301 info.SetCheckable(true);
302 info.SetHint("testapp_B1_findFocus");
303 callback.SetFindFocusedElementInfoResult(info, requestId);
304 HILOG_INFO("##############AamsStAbilityB1::=======FindFocusedElementInfo=======success=======");
305 }
306
FocusMoveSearch(const long elementId,const int direction,const int requestId,Accessibility::AccessibilityInteractionOperationCallback & callback)307 void AccessibilityInteractionOperationTest::FocusMoveSearch(const long elementId, const int direction,
308 const int requestId, Accessibility::AccessibilityInteractionOperationCallback &callback)
309 {
310 HILOG_INFO("##############AamsStAbilityB1:: start");
311 AccessibilityElementInfo info;
312 info.SetWindowId(0);
313 info.SetBundleName("testapp_B1_FocusMoveSearch");
314 info.SetCheckable(true);
315 info.SetHint("testapp_B1_FocusMoveSearch");
316 int parentId = 2;
317 info.SetParent(parentId);
318
319 callback.SetFocusMoveSearchResult(info, requestId);
320 HILOG_INFO("##############AamsStAbilityB1::=======FocusMoveSearch=======success=======");
321 }
322
PerformAction(const long elementId,const int action,const std::map<std::string,std::string> actionArguments,int requestId,Accessibility::AccessibilityInteractionOperationCallback & callback)323 void AccessibilityInteractionOperationTest::PerformAction(const long elementId, const int action,
324 const std::map<std::string, std::string> actionArguments,
325 int requestId, Accessibility::AccessibilityInteractionOperationCallback &callback)
326 {
327 HILOG_INFO("##############AamsStAbilityB1:: start");
328 AccessibilityElementInfo info;
329 info.SetWindowId(0);
330 info.SetBundleName("testapp_B1_findFocus");
331 info.SetCheckable(true);
332 info.SetHint("testapp_B1_findFocus");
333 callback.SetPerformActionResult(true, requestId);
334 HILOG_INFO("##############AamsStAbilityB1::=======PerformAction=======success=======");
335 }
336
ClearFocus()337 void AccessibilityInteractionOperationTest::ClearFocus()
338 {
339 HILOG_INFO("##############AamsStAbilityB1:: start");
340 }
341
OutsideTouch()342 void AccessibilityInteractionOperationTest::OutsideTouch()
343 {
344 HILOG_INFO("##############AamsStAbilityB1:: start");
345 }
346
OnStateChanged(const Accessibility::AccessibilityStateEvent & stateEvent)347 void AccessibilityStateObserverTest::OnStateChanged(const Accessibility::AccessibilityStateEvent& stateEvent)
348 {
349 HILOG_INFO("##############AamsStAbilityB1:: start");
350 }
351
352 REGISTER_AA(AamsStAbilityB1);
353 } // namespace AppExecFwk
354 } // namespace OHOS