1 /*
2 * Copyright (c) 2023 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 <gtest/gtest.h>
17
18 #include "intention_event/include/intention_event_manager.h"
19 #include "mock_uicontent.h"
20 #include "session/host/include/scene_session.h"
21 #include "session_manager/include/scene_session_manager.h"
22
23 using namespace testing;
24 using namespace testing::ext;
25
26 namespace OHOS {
27 namespace Rosen {
28 class IntentionEventManagerTest : public testing::Test {
29 public:
30 static void SetUpTestCase();
31 static void TearDownTestCase();
32 void SetUp() override;
33 void TearDown() override;
34 std::unique_ptr<Ace::UIContent> uIContent_;
35 std::shared_ptr<AppExecFwk::EventHandler> eventHandler_;
36 std::shared_ptr<IntentionEventManager::InputEventListener> inputEventListener_;
37 std::shared_ptr<AppExecFwk::EventRunner> runner_;
38 static constexpr uint32_t WAIT_SYNC_IN_NS = 500000;
39 };
40
SetUpTestCase()41 void IntentionEventManagerTest::SetUpTestCase()
42 {
43 }
44
TearDownTestCase()45 void IntentionEventManagerTest::TearDownTestCase()
46 {
47 }
48
SetUp()49 void IntentionEventManagerTest::SetUp()
50 {
51 uIContent_ = std::make_unique<Ace::UIContentMocker>();
52 EXPECT_NE(nullptr, uIContent_);
53 runner_ = AppExecFwk::EventRunner::Create("TestRunner");
54 eventHandler_ = std::make_shared<AppExecFwk::EventHandler>(runner_);
55 EXPECT_NE(nullptr, eventHandler_);
56 inputEventListener_ =
57 std::make_shared<IntentionEventManager::InputEventListener>(uIContent_.get(), eventHandler_);
58 EXPECT_NE(nullptr, inputEventListener_);
59 SceneSessionManager::GetInstance().sceneSessionMap_.clear();
60 }
61
TearDown()62 void IntentionEventManagerTest::TearDown()
63 {
64 uIContent_ = nullptr;
65 eventHandler_ = nullptr;
66 inputEventListener_ = nullptr;
67 runner_ = nullptr;
68 SceneSessionManager::GetInstance().sceneSessionMap_.clear();
69 }
70
71 namespace {
72 /**
73 * @tc.name: EnableInputEventListener
74 * @tc.desc: EnableInputEventListener Test
75 * @tc.type: FUNC
76 */
77 HWTEST_F(IntentionEventManagerTest, EnableInputEventListener, Function | MediumTest | Level2)
78 {
79 bool enable = DelayedSingleton<IntentionEventManager>::GetInstance()->
80 EnableInputEventListener(nullptr, nullptr);
81 EXPECT_EQ(false, enable);
82 enable = DelayedSingleton<IntentionEventManager>::GetInstance()->
83 EnableInputEventListener(uIContent_.get(), nullptr);
84 EXPECT_EQ(false, enable);
85 enable = DelayedSingleton<IntentionEventManager>::GetInstance()->
86 EnableInputEventListener(uIContent_.get(), eventHandler_);
87 EXPECT_EQ(true, enable);
88 }
89
90 /**
91 * @tc.name: OnInputEvent0
92 * @tc.desc: OnInputEvent0 Test
93 * @tc.type: FUNC
94 */
95 HWTEST_F(IntentionEventManagerTest, OnInputEvent0, Function | MediumTest | Level2)
96 {
97 std::shared_ptr<MMI::PointerEvent> pointerEvent = nullptr;
98 inputEventListener_->OnInputEvent(pointerEvent);
99 pointerEvent = MMI::PointerEvent::Create();
100 EXPECT_NE(nullptr, pointerEvent);
101
102 pointerEvent->SetTargetWindowId(0);
103 inputEventListener_->OnInputEvent(pointerEvent);
104
105 SessionInfo info;
106 info.bundleName_ = "IntentionEventManager";
107 info.moduleName_ = "InputEventListener";
108 info.isSystem_ = true;
109 sptr<SceneSession::SpecificSessionCallback> callback =
110 sptr<SceneSession::SpecificSessionCallback>::MakeSptr();
111 EXPECT_NE(nullptr, callback);
112 sptr<SceneSession> sceneSession0 = sptr<SceneSession>::MakeSptr(info, callback);
113 EXPECT_NE(nullptr, sceneSession0);
114 SceneSessionManager::GetInstance().sceneSessionMap_.emplace(std::make_pair(0, sceneSession0));
115
116 pointerEvent->SetDispatchTimes(10);
117 EXPECT_EQ(10, pointerEvent->GetDispatchTimes());
118 pointerEvent->SetPointerId(10);
119 EXPECT_EQ(10, pointerEvent->GetPointerId());
120
121 MMI::PointerEvent::PointerItem item;
122 item.SetPointerId(10);
123 EXPECT_EQ(10, item.GetPointerId());
124 pointerEvent->AddPointerItem(item);
125
126 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_UP);
127 EXPECT_EQ(MMI::PointerEvent::POINTER_ACTION_UP, pointerEvent->GetPointerAction());
128 inputEventListener_->OnInputEvent(pointerEvent);
129
130 info.isSystem_ = false;
131 sptr<SceneSession> sceneSession1 = sptr<SceneSession>::MakeSptr(info, callback);
132 EXPECT_NE(nullptr, sceneSession1);
133 SceneSessionManager::GetInstance().sceneSessionMap_.emplace(std::make_pair(1, sceneSession1));
134 pointerEvent->SetTargetWindowId(1);
135 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
136 EXPECT_NE(nullptr, property);
137 property->SetWindowType(WindowType::WINDOW_TYPE_SYSTEM_FLOAT);
138 sceneSession1->SetSessionProperty(property);
139 inputEventListener_->OnInputEvent(pointerEvent);
140 EXPECT_EQ(200010, pointerEvent->GetPointerId());
141 }
142
143 /**
144 * @tc.name: OnInputEvent1
145 * @tc.desc: OnInputEvent1 Test
146 * @tc.type: FUNC
147 */
148 HWTEST_F(IntentionEventManagerTest, OnInputEvent1, Function | MediumTest | Level2)
149 {
150 std::shared_ptr<MMI::KeyEvent> keyEvent = nullptr;
151 inputEventListener_->OnInputEvent(keyEvent);
152 keyEvent = MMI::KeyEvent::Create();
153 EXPECT_NE(nullptr, keyEvent);
154 SceneSessionManager::GetInstance().SetEnableInputEvent(false);
155 EXPECT_EQ(false, SceneSessionManager::GetInstance().IsInputEventEnabled());
156 inputEventListener_->OnInputEvent(keyEvent);
157
158 SceneSessionManager::GetInstance().SetEnableInputEvent(true);
159 SceneSessionManager::GetInstance().SetFocusedSessionId(INVALID_SESSION_ID, DEFAULT_DISPLAY_ID);
160 EXPECT_EQ(INVALID_SESSION_ID, SceneSessionManager::GetInstance().GetFocusedSessionId());
161 inputEventListener_->OnInputEvent(keyEvent);
162
163 SceneSessionManager::GetInstance().SetFocusedSessionId(1, DEFAULT_DISPLAY_ID);
164 inputEventListener_->OnInputEvent(keyEvent);
165
166 SessionInfo info;
167 info.bundleName_ = "IntentionEventManager";
168 info.moduleName_ = "InputEventListener";
169 info.isSystem_ = true;
170 sptr<SceneSession::SpecificSessionCallback> callback =
171 sptr<SceneSession::SpecificSessionCallback>::MakeSptr();
172 EXPECT_NE(nullptr, callback);
173 sptr<SceneSession> sceneSession0 = sptr<SceneSession>::MakeSptr(info, callback);
174 EXPECT_NE(nullptr, sceneSession0);
175 SceneSessionManager::GetInstance().sceneSessionMap_.emplace(std::make_pair(1, sceneSession0));
176 EXPECT_EQ(1, SceneSessionManager::GetInstance().sceneSessionMap_.size());
177 inputEventListener_->OnInputEvent(keyEvent);
178
179 info.isSystem_ = false;
180 sptr<SceneSession> sceneSession1 = sptr<SceneSession>::MakeSptr(info, callback);
181 EXPECT_NE(nullptr, sceneSession1);
182 SceneSessionManager::GetInstance().sceneSessionMap_.emplace(std::make_pair(2, sceneSession1));
183 SceneSessionManager::GetInstance().SetFocusedSessionId(2, DEFAULT_DISPLAY_ID);
184 EXPECT_EQ(2, SceneSessionManager::GetInstance().GetFocusedSessionId());
185 auto focusedSceneSession = SceneSessionManager::GetInstance().GetSceneSession(2);
186 inputEventListener_->OnInputEvent(keyEvent);
187 EXPECT_NE(nullptr, focusedSceneSession);
188 }
189
190 /**
191 * @tc.name: OnInputEvent2
192 * @tc.desc: OnInputEvent2 Test
193 * @tc.type: FUNC
194 */
195 HWTEST_F(IntentionEventManagerTest, OnInputEvent2, Function | MediumTest | Level2)
196 {
197 std::shared_ptr<MMI::KeyEvent> keyEvent = MMI::KeyEvent::Create();
198 EXPECT_NE(nullptr, keyEvent);
199 SceneSessionManager::GetInstance().SetEnableInputEvent(true);
200 SceneSessionManager::GetInstance().SetFocusedSessionId(1, DEFAULT_DISPLAY_ID);
201 SessionInfo info;
202 info.bundleName_ = "IntentionEventManager";
203 info.moduleName_ = "InputEventListener";
204 info.isSystem_ = true;
205 sptr<SceneSession::SpecificSessionCallback> callback =
206 sptr<SceneSession::SpecificSessionCallback>::MakeSptr();
207 EXPECT_NE(nullptr, callback);
208 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, callback);
209 EXPECT_NE(nullptr, sceneSession);
__anon2a146aac0202(std::shared_ptr<MMI::KeyEvent> keyEvent, bool isPreImeEvent) 210 auto func = [](std::shared_ptr<MMI::KeyEvent> keyEvent, bool isPreImeEvent) {
211 return true;
212 };
213 sceneSession->SetNotifySystemSessionKeyEventFunc(func);
214 SceneSessionManager::GetInstance().sceneSessionMap_.emplace(std::make_pair(1, sceneSession));
215 EXPECT_EQ(1, SceneSessionManager::GetInstance().sceneSessionMap_.size());
216 inputEventListener_->OnInputEvent(keyEvent);
217 sceneSession->SetNotifySystemSessionKeyEventFunc(nullptr);
218 keyEvent->SetKeyCode(MMI::KeyEvent::KEYCODE_FN);
219 EXPECT_EQ(MMI::KeyEvent::KEYCODE_FN, keyEvent->GetKeyCode());
220 auto focusedSceneSession = SceneSessionManager::GetInstance().GetSceneSession(1);
221 inputEventListener_->OnInputEvent(keyEvent);
222 EXPECT_NE(nullptr, focusedSceneSession);
223 }
224
225 /**
226 * @tc.name: OnInputEvent3
227 * @tc.desc: OnInputEvent3 Test
228 * @tc.type: FUNC
229 */
230 HWTEST_F(IntentionEventManagerTest, OnInputEvent3, Function | MediumTest | Level2)
231 {
232 std::shared_ptr<IntentionEventManager::InputEventListener> inputEventListener =
233 std::make_shared<IntentionEventManager::InputEventListener>(nullptr, nullptr);
234 EXPECT_NE(nullptr, inputEventListener);
235 std::shared_ptr<MMI::KeyEvent> keyEvent = MMI::KeyEvent::Create();
236 EXPECT_NE(nullptr, keyEvent);
237 SceneSessionManager::GetInstance().SetEnableInputEvent(true);
238 SceneSessionManager::GetInstance().SetFocusedSessionId(1, DEFAULT_DISPLAY_ID);
239 SessionInfo info;
240 info.bundleName_ = "IntentionEventManager";
241 info.moduleName_ = "InputEventListener";
242 info.isSystem_ = true;
243 sptr<SceneSession::SpecificSessionCallback> callback =
244 sptr<SceneSession::SpecificSessionCallback>::MakeSptr();
245 EXPECT_NE(nullptr, callback);
246 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, callback);
247 EXPECT_NE(nullptr, sceneSession);
248 sceneSession->SetNotifySystemSessionKeyEventFunc(nullptr);
249 SceneSessionManager::GetInstance().sceneSessionMap_.emplace(std::make_pair(1, sceneSession));
250 EXPECT_EQ(1, SceneSessionManager::GetInstance().sceneSessionMap_.size());
251 keyEvent->SetKeyCode(MMI::KeyEvent::KEYCODE_UNKNOWN);
252 EXPECT_EQ(MMI::KeyEvent::KEYCODE_UNKNOWN, keyEvent->GetKeyCode());
253 inputEventListener->OnInputEvent(keyEvent);
254 auto focusedSceneSession = SceneSessionManager::GetInstance().GetSceneSession(1);
255 inputEventListener_->OnInputEvent(keyEvent);
256 EXPECT_NE(nullptr, focusedSceneSession);
257 }
258
259 /**
260 * @tc.name: OnInputEvent4
261 * @tc.desc: OnInputEvent4 Test
262 * @tc.type: FUNC
263 */
264 HWTEST_F(IntentionEventManagerTest, OnInputEvent4, Function | MediumTest | Level2)
265 {
266 std::shared_ptr<IntentionEventManager::InputEventListener> inputEventListener =
267 std::make_shared<IntentionEventManager::InputEventListener>(nullptr, nullptr);
268 EXPECT_EQ(nullptr, inputEventListener->uiContent_);
269 std::shared_ptr<MMI::AxisEvent> axisEvent = nullptr;
270 inputEventListener->OnInputEvent(axisEvent);
271 axisEvent = MMI::AxisEvent::Create();
272 EXPECT_NE(nullptr, axisEvent);
273 inputEventListener->OnInputEvent(axisEvent);
274 }
275
276 /**
277 * @tc.name: IsKeyboardEvent
278 * @tc.desc: IsKeyboardEvent Test
279 * @tc.type: FUNC
280 */
281 HWTEST_F(IntentionEventManagerTest, IsKeyboardEvent, Function | MediumTest | Level2)
282 {
283 std::shared_ptr<MMI::KeyEvent> keyEvent = MMI::KeyEvent::Create();
284 EXPECT_NE(nullptr, keyEvent);
285 keyEvent->SetKeyCode(MMI::KeyEvent::KEYCODE_BACK);
286 EXPECT_EQ(true, inputEventListener_->IsKeyboardEvent(keyEvent));
287 usleep(WAIT_SYNC_IN_NS);
288 }
289
290 /**
291 * @tc.name: DispatchKeyEventCallback
292 * @tc.desc: DispatchKeyEventCallback Test
293 * @tc.type: FUNC
294 */
295 HWTEST_F(IntentionEventManagerTest, DispatchKeyEventCallback, Function | MediumTest | Level2)
296 {
297 std::shared_ptr<MMI::KeyEvent> keyEvent = nullptr;
298 inputEventListener_->DispatchKeyEventCallback(2024, keyEvent, true);
299 keyEvent = MMI::KeyEvent::Create();
300 EXPECT_NE(nullptr, keyEvent);
301 inputEventListener_->DispatchKeyEventCallback(2024, keyEvent, true);
302 inputEventListener_->DispatchKeyEventCallback(2024, keyEvent, false);
303 SessionInfo info;
304 info.bundleName_ = "IntentionEventManager";
305 info.moduleName_ = "InputEventListener";
306 sptr<SceneSession::SpecificSessionCallback> callback =
307 sptr<SceneSession::SpecificSessionCallback>::MakeSptr();
308 EXPECT_NE(nullptr, callback);
309 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, callback);
310 EXPECT_NE(nullptr, sceneSession);
311 SceneSessionManager::GetInstance().sceneSessionMap_.emplace(std::make_pair(2024, sceneSession));
312 std::shared_ptr<IntentionEventManager::InputEventListener> inputEventListener =
313 std::make_shared<IntentionEventManager::InputEventListener>(nullptr, nullptr);
314 inputEventListener->DispatchKeyEventCallback(2024, keyEvent, false);
315 inputEventListener_->DispatchKeyEventCallback(2024, keyEvent, false);
316 }
317
318 /**
319 * @tc.name: CheckPointerEvent
320 * @tc.desc: CheckPointerEvent Test
321 * @tc.type: FUNC
322 */
323 HWTEST_F(IntentionEventManagerTest, CheckPointerEvent, Function | MediumTest | Level2)
324 {
325 std::shared_ptr<MMI::PointerEvent> pointerEvent = nullptr;
326 std::shared_ptr<IntentionEventManager::InputEventListener> inputEventListener =
327 std::make_shared<IntentionEventManager::InputEventListener>(nullptr, nullptr);
328 EXPECT_NE(nullptr, inputEventListener);
329 EXPECT_EQ(false, inputEventListener->CheckPointerEvent(pointerEvent));
330 pointerEvent = MMI::PointerEvent::Create();
331 EXPECT_EQ(false, inputEventListener->CheckPointerEvent(pointerEvent));
332 SceneSessionManager::GetInstance().SetEnableInputEvent(false);
333 EXPECT_EQ(false, inputEventListener_->CheckPointerEvent(pointerEvent));
334 SceneSessionManager::GetInstance().SetEnableInputEvent(true);
335 pointerEvent->SetDispatchTimes(10);
336 EXPECT_EQ(10, pointerEvent->GetDispatchTimes());
337 EXPECT_EQ(true, inputEventListener_->CheckPointerEvent(pointerEvent));
338 }
339
340 /**
341 * @tc.name: OnInputEventPointer1
342 * @tc.desc: OnInputEventPointer1 Test
343 * @tc.type: FUNC
344 */
345 HWTEST_F(IntentionEventManagerTest, OnInputEventPointer1, Function | MediumTest | Level2)
346 {
347 auto pointerEvent = MMI::PointerEvent::Create();
348 EXPECT_NE(nullptr, pointerEvent);
349 SessionInfo info;
350 info.bundleName_ = "IntentionEventManager";
351 info.moduleName_ = "InputEventListener";
352 info.isSystem_ = true;
353 sptr<SceneSession::SpecificSessionCallback> callback =
354 sptr<SceneSession::SpecificSessionCallback>::MakeSptr();
355 EXPECT_NE(nullptr, callback);
356 sptr<SceneSession> sceneSession0 = sptr<SceneSession>::MakeSptr(info, callback);
357 EXPECT_NE(nullptr, sceneSession0);
358 SceneSessionManager::GetInstance().sceneSessionMap_.emplace(std::make_pair(0, sceneSession0));
359 pointerEvent->SetDispatchTimes(-1);
360 EXPECT_EQ(-1, pointerEvent->GetDispatchTimes());
361 pointerEvent->SetPointerId(10);
362 EXPECT_EQ(10, pointerEvent->GetPointerId());
363 MMI::PointerEvent::PointerItem item;
364 item.SetPointerId(10);
365 EXPECT_EQ(10, item.GetPointerId());
366 pointerEvent->AddPointerItem(item);
367 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_MOVE);
368 EXPECT_EQ(MMI::PointerEvent::POINTER_ACTION_MOVE, pointerEvent->GetPointerAction());
369 inputEventListener_->OnInputEvent(pointerEvent);
370
371 pointerEvent->pointers_.clear();
372 pointerEvent->SetDispatchTimes(10);
373 inputEventListener_->OnInputEvent(pointerEvent);
374
375 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_DOWN);
376 inputEventListener_->OnInputEvent(pointerEvent);
377 pointerEvent->AddPointerItem(item);
378 inputEventListener_->OnInputEvent(pointerEvent);
379 }
380
381 /**
382 * @tc.name: SetPointerEventStatus
383 * @tc.desc: SetPointerEventStatus Test
384 * @tc.type: FUNC
385 */
386 HWTEST_F(IntentionEventManagerTest, SetPointerEventStatus, Function | MediumTest | Level2)
387 {
388 SessionInfo info;
389 info.abilityName_ = "SetPointerEventStatus";
390 info.bundleName_ = "SetPointerEventStatus";
391 info.windowType_ = 1;
392 sptr<SceneSession::SpecificSessionCallback> specificCallback =
393 sptr<SceneSession::SpecificSessionCallback>::MakeSptr();
394 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, specificCallback);
395 EXPECT_NE(sceneSession, nullptr);
396
397 int32_t action = MMI::PointerEvent::POINTER_ACTION_DOWN;
398 inputEventListener_->SetPointerEventStatus(0, action, MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, sceneSession);
399 auto fingerPointerDownStatusList = sceneSession->GetFingerPointerDownStatusList();
400 EXPECT_EQ(1, fingerPointerDownStatusList.size());
401
402 action = MMI::PointerEvent::POINTER_ACTION_UP;
403 inputEventListener_->SetPointerEventStatus(0, action, MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, sceneSession);
404 fingerPointerDownStatusList = sceneSession->GetFingerPointerDownStatusList();
405 EXPECT_EQ(0, fingerPointerDownStatusList.size());
406
407 action = MMI::PointerEvent::POINTER_ACTION_BUTTON_DOWN;
408 inputEventListener_->SetPointerEventStatus(1, action, MMI::PointerEvent::SOURCE_TYPE_MOUSE, sceneSession);
409 EXPECT_EQ(true, sceneSession->GetMousePointerDownEventStatus());
410
411 action = MMI::PointerEvent::POINTER_ACTION_BUTTON_UP;
412 inputEventListener_->SetPointerEventStatus(1, action, MMI::PointerEvent::SOURCE_TYPE_MOUSE, sceneSession);
413 EXPECT_EQ(false, sceneSession->GetMousePointerDownEventStatus());
414
415 action = MMI::PointerEvent::POINTER_ACTION_DOWN;
416 inputEventListener_->SetPointerEventStatus(0, action, MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, sceneSession);
417 action = MMI::PointerEvent::POINTER_ACTION_CANCEL;
418 inputEventListener_->SetPointerEventStatus(0, action, MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, sceneSession);
419 fingerPointerDownStatusList = sceneSession->GetFingerPointerDownStatusList();
420 EXPECT_EQ(0, fingerPointerDownStatusList.size());
421
422 action = MMI::PointerEvent::POINTER_ACTION_BUTTON_DOWN;
423 inputEventListener_->SetPointerEventStatus(1, action, MMI::PointerEvent::SOURCE_TYPE_MOUSE, sceneSession);
424 action = MMI::PointerEvent::POINTER_ACTION_CANCEL;
425 inputEventListener_->SetPointerEventStatus(0, action, MMI::PointerEvent::SOURCE_TYPE_MOUSE, sceneSession);
426 EXPECT_EQ(false, sceneSession->GetMousePointerDownEventStatus());
427 }
428 }
429 }
430 }