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         new SceneSession::SpecificSessionCallback();
111     EXPECT_NE(nullptr, callback);
112     sptr<SceneSession> sceneSession0 = new SceneSession(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 = new SceneSession(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 = new WindowSessionProperty();
136     EXPECT_NE(nullptr, property);
137     property->SetWindowType(WindowType::WINDOW_TYPE_SYSTEM_FLOAT);
138     sceneSession1->SetSessionProperty(property);
139     inputEventListener_->OnInputEvent(pointerEvent);
140 }
141 
142 /**
143  * @tc.name: OnInputEvent1
144  * @tc.desc: OnInputEvent1 Test
145  * @tc.type: FUNC
146  */
147 HWTEST_F(IntentionEventManagerTest, OnInputEvent1, Function | MediumTest | Level2)
148 {
149     std::shared_ptr<MMI::KeyEvent> keyEvent = nullptr;
150     inputEventListener_->OnInputEvent(keyEvent);
151     keyEvent = MMI::KeyEvent::Create();
152     EXPECT_NE(nullptr, keyEvent);
153     SceneSessionManager::GetInstance().SetEnableInputEvent(false);
154     EXPECT_EQ(false, SceneSessionManager::GetInstance().IsInputEventEnabled());
155     inputEventListener_->OnInputEvent(keyEvent);
156 
157     SceneSessionManager::GetInstance().SetEnableInputEvent(true);
158     SceneSessionManager::GetInstance().SetFocusedSessionId(INVALID_SESSION_ID);
159     EXPECT_EQ(INVALID_SESSION_ID, SceneSessionManager::GetInstance().GetFocusedSessionId());
160     inputEventListener_->OnInputEvent(keyEvent);
161 
162     SceneSessionManager::GetInstance().SetFocusedSessionId(1);
163     inputEventListener_->OnInputEvent(keyEvent);
164 
165     SessionInfo info;
166     info.bundleName_ = "IntentionEventManager";
167     info.moduleName_ = "InputEventListener";
168     info.isSystem_ = true;
169     sptr<SceneSession::SpecificSessionCallback> callback =
170         new SceneSession::SpecificSessionCallback();
171     EXPECT_NE(nullptr, callback);
172     sptr<SceneSession> sceneSession0 = new SceneSession(info, callback);
173     EXPECT_NE(nullptr, sceneSession0);
174     SceneSessionManager::GetInstance().sceneSessionMap_.emplace(std::make_pair(1, sceneSession0));
175     EXPECT_EQ(1, SceneSessionManager::GetInstance().sceneSessionMap_.size());
176     inputEventListener_->OnInputEvent(keyEvent);
177 
178     info.isSystem_ = false;
179     sptr<SceneSession> sceneSession1 = new SceneSession(info, callback);
180     EXPECT_NE(nullptr, sceneSession1);
181     SceneSessionManager::GetInstance().sceneSessionMap_.emplace(std::make_pair(2, sceneSession1));
182     SceneSessionManager::GetInstance().SetFocusedSessionId(2);
183     EXPECT_EQ(2, SceneSessionManager::GetInstance().GetFocusedSessionId());
184     inputEventListener_->OnInputEvent(keyEvent);
185 }
186 
187 /**
188  * @tc.name: OnInputEvent2
189  * @tc.desc: OnInputEvent2 Test
190  * @tc.type: FUNC
191  */
192 HWTEST_F(IntentionEventManagerTest, OnInputEvent2, Function | MediumTest | Level2)
193 {
194     std::shared_ptr<MMI::KeyEvent> keyEvent = MMI::KeyEvent::Create();
195     EXPECT_NE(nullptr, keyEvent);
196     SceneSessionManager::GetInstance().SetEnableInputEvent(true);
197     SceneSessionManager::GetInstance().SetFocusedSessionId(1);
198     SessionInfo info;
199     info.bundleName_ = "IntentionEventManager";
200     info.moduleName_ = "InputEventListener";
201     info.isSystem_ = true;
202     sptr<SceneSession::SpecificSessionCallback> callback =
203         new SceneSession::SpecificSessionCallback();
204     EXPECT_NE(nullptr, callback);
205     sptr<SceneSession> sceneSession = new SceneSession(info, callback);
206     EXPECT_NE(nullptr, sceneSession);
__anone07782a40202(std::shared_ptr<MMI::KeyEvent> keyEvent, bool isPreImeEvent) 207     auto func = [](std::shared_ptr<MMI::KeyEvent> keyEvent, bool isPreImeEvent) {
208         return true;
209     };
210     sceneSession->SetNotifySystemSessionKeyEventFunc(func);
211     SceneSessionManager::GetInstance().sceneSessionMap_.emplace(std::make_pair(1, sceneSession));
212     EXPECT_EQ(1, SceneSessionManager::GetInstance().sceneSessionMap_.size());
213     inputEventListener_->OnInputEvent(keyEvent);
214     sceneSession->SetNotifySystemSessionKeyEventFunc(nullptr);
215     keyEvent->SetKeyCode(MMI::KeyEvent::KEYCODE_FN);
216     EXPECT_EQ(MMI::KeyEvent::KEYCODE_FN, keyEvent->GetKeyCode());
217     inputEventListener_->OnInputEvent(keyEvent);
218 }
219 
220 /**
221  * @tc.name: OnInputEvent3
222  * @tc.desc: OnInputEvent3 Test
223  * @tc.type: FUNC
224  */
225 HWTEST_F(IntentionEventManagerTest, OnInputEvent3, Function | MediumTest | Level2)
226 {
227     std::shared_ptr<IntentionEventManager::InputEventListener> inputEventListener =
228         std::make_shared<IntentionEventManager::InputEventListener>(nullptr, nullptr);
229     EXPECT_NE(nullptr, inputEventListener);
230     std::shared_ptr<MMI::KeyEvent> keyEvent = MMI::KeyEvent::Create();
231     EXPECT_NE(nullptr, keyEvent);
232     SceneSessionManager::GetInstance().SetEnableInputEvent(true);
233     SceneSessionManager::GetInstance().SetFocusedSessionId(1);
234     SessionInfo info;
235     info.bundleName_ = "IntentionEventManager";
236     info.moduleName_ = "InputEventListener";
237     info.isSystem_ = true;
238     sptr<SceneSession::SpecificSessionCallback> callback =
239         new SceneSession::SpecificSessionCallback();
240     EXPECT_NE(nullptr, callback);
241     sptr<SceneSession> sceneSession = new SceneSession(info, callback);
242     EXPECT_NE(nullptr, sceneSession);
243     sceneSession->SetNotifySystemSessionKeyEventFunc(nullptr);
244     SceneSessionManager::GetInstance().sceneSessionMap_.emplace(std::make_pair(1, sceneSession));
245     EXPECT_EQ(1, SceneSessionManager::GetInstance().sceneSessionMap_.size());
246     keyEvent->SetKeyCode(MMI::KeyEvent::KEYCODE_UNKNOWN);
247     EXPECT_EQ(MMI::KeyEvent::KEYCODE_UNKNOWN, keyEvent->GetKeyCode());
248     inputEventListener->OnInputEvent(keyEvent);
249     inputEventListener_->OnInputEvent(keyEvent);
250 }
251 
252 /**
253  * @tc.name: OnInputEvent4
254  * @tc.desc: OnInputEvent4 Test
255  * @tc.type: FUNC
256  */
257 HWTEST_F(IntentionEventManagerTest, OnInputEvent4, Function | MediumTest | Level2)
258 {
259     std::shared_ptr<IntentionEventManager::InputEventListener> inputEventListener =
260         std::make_shared<IntentionEventManager::InputEventListener>(nullptr, nullptr);
261     EXPECT_EQ(nullptr, inputEventListener->uiContent_);
262     std::shared_ptr<MMI::AxisEvent> axisEvent = nullptr;
263     inputEventListener->OnInputEvent(axisEvent);
264     axisEvent = MMI::AxisEvent::Create();
265     EXPECT_NE(nullptr, axisEvent);
266     inputEventListener->OnInputEvent(axisEvent);
267 }
268 
269 /**
270  * @tc.name: IsKeyboardEvent
271  * @tc.desc: IsKeyboardEvent Test
272  * @tc.type: FUNC
273  */
274 HWTEST_F(IntentionEventManagerTest, IsKeyboardEvent, Function | MediumTest | Level2)
275 {
276     std::shared_ptr<MMI::KeyEvent> keyEvent = MMI::KeyEvent::Create();
277     EXPECT_NE(nullptr, keyEvent);
278     keyEvent->SetKeyCode(MMI::KeyEvent::KEYCODE_BACK);
279     EXPECT_EQ(true, inputEventListener_->IsKeyboardEvent(keyEvent));
280     usleep(WAIT_SYNC_IN_NS);
281 }
282 
283 /**
284  * @tc.name: DispatchKeyEventCallback
285  * @tc.desc: DispatchKeyEventCallback Test
286  * @tc.type: FUNC
287  */
288 HWTEST_F(IntentionEventManagerTest, DispatchKeyEventCallback, Function | MediumTest | Level2)
289 {
290     std::shared_ptr<MMI::KeyEvent> keyEvent = nullptr;
291     inputEventListener_->DispatchKeyEventCallback(2024, keyEvent, true);
292     keyEvent = MMI::KeyEvent::Create();
293     EXPECT_NE(nullptr, keyEvent);
294     inputEventListener_->DispatchKeyEventCallback(2024, keyEvent, true);
295     inputEventListener_->DispatchKeyEventCallback(2024, keyEvent, false);
296     SessionInfo info;
297     info.bundleName_ = "IntentionEventManager";
298     info.moduleName_ = "InputEventListener";
299     sptr<SceneSession::SpecificSessionCallback> callback =
300         new SceneSession::SpecificSessionCallback();
301     EXPECT_NE(nullptr, callback);
302     sptr<SceneSession> sceneSession = new SceneSession(info, callback);
303     EXPECT_NE(nullptr, sceneSession);
304     SceneSessionManager::GetInstance().sceneSessionMap_.emplace(std::make_pair(2024, sceneSession));
305     std::shared_ptr<IntentionEventManager::InputEventListener> inputEventListener =
306         std::make_shared<IntentionEventManager::InputEventListener>(nullptr, nullptr);
307     inputEventListener->DispatchKeyEventCallback(2024, keyEvent, false);
308     inputEventListener_->DispatchKeyEventCallback(2024, keyEvent, false);
309 }
310 
311 /**
312  * @tc.name: CheckPointerEvent
313  * @tc.desc: CheckPointerEvent Test
314  * @tc.type: FUNC
315  */
316 HWTEST_F(IntentionEventManagerTest, CheckPointerEvent, Function | MediumTest | Level2)
317 {
318     std::shared_ptr<MMI::PointerEvent> pointerEvent = nullptr;
319     std::shared_ptr<IntentionEventManager::InputEventListener> inputEventListener =
320         std::make_shared<IntentionEventManager::InputEventListener>(nullptr, nullptr);
321     EXPECT_NE(nullptr, inputEventListener);
322     EXPECT_EQ(false, inputEventListener->CheckPointerEvent(pointerEvent));
323     pointerEvent = MMI::PointerEvent::Create();
324     EXPECT_EQ(false, inputEventListener->CheckPointerEvent(pointerEvent));
325     SceneSessionManager::GetInstance().SetEnableInputEvent(false);
326     EXPECT_EQ(false, inputEventListener_->CheckPointerEvent(pointerEvent));
327     SceneSessionManager::GetInstance().SetEnableInputEvent(true);
328     pointerEvent->SetDispatchTimes(10);
329     EXPECT_EQ(10, pointerEvent->GetDispatchTimes());
330     EXPECT_EQ(true, inputEventListener_->CheckPointerEvent(pointerEvent));
331 }
332 
333 /**
334  * @tc.name: UpdateLastMouseEvent
335  * @tc.desc: UpdateLastMouseEvent Test
336  * @tc.type: FUNC
337  */
338 HWTEST_F(IntentionEventManagerTest, UpdateLastMouseEvent, Function | MediumTest | Level2)
339 {
340     std::shared_ptr<MMI::PointerEvent> pointerEvent = nullptr;
341     inputEventListener_->UpdateLastMouseEvent(pointerEvent);
342     pointerEvent = MMI::PointerEvent::Create();
343     pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
344     pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_UP);
345     EXPECT_EQ(MMI::PointerEvent::SOURCE_TYPE_MOUSE, pointerEvent->GetSourceType());
346     EXPECT_NE(MMI::PointerEvent::POINTER_ACTION_LEAVE_WINDOW, pointerEvent->GetPointerAction());
347     inputEventListener_->UpdateLastMouseEvent(pointerEvent);
348 
349     pointerEvent->SetSourceType(MMI::PointerEvent::POINTER_ACTION_DOWN);
350     pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_LEAVE_WINDOW);
351     inputEventListener_->UpdateLastMouseEvent(pointerEvent);
352 
353     pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
354     pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_LEAVE_WINDOW);
355     inputEventListener_->UpdateLastMouseEvent(pointerEvent);
356 }
357 
358 /**
359  * @tc.name: OnInputEventPointer1
360  * @tc.desc: OnInputEventPointer1 Test
361  * @tc.type: FUNC
362  */
363 HWTEST_F(IntentionEventManagerTest, OnInputEventPointer1, Function | MediumTest | Level2)
364 {
365     auto pointerEvent = MMI::PointerEvent::Create();
366     EXPECT_NE(nullptr, pointerEvent);
367     SessionInfo info;
368     info.bundleName_ = "IntentionEventManager";
369     info.moduleName_ = "InputEventListener";
370     info.isSystem_ = true;
371     sptr<SceneSession::SpecificSessionCallback> callback =
372         new SceneSession::SpecificSessionCallback();
373     EXPECT_NE(nullptr, callback);
374     sptr<SceneSession> sceneSession0 = new SceneSession(info, callback);
375     EXPECT_NE(nullptr, sceneSession0);
376     SceneSessionManager::GetInstance().sceneSessionMap_.emplace(std::make_pair(0, sceneSession0));
377     pointerEvent->SetDispatchTimes(-1);
378     EXPECT_EQ(-1, pointerEvent->GetDispatchTimes());
379     pointerEvent->SetPointerId(10);
380     EXPECT_EQ(10, pointerEvent->GetPointerId());
381     MMI::PointerEvent::PointerItem item;
382     item.SetPointerId(10);
383     EXPECT_EQ(10, item.GetPointerId());
384     pointerEvent->AddPointerItem(item);
385     pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_MOVE);
386     EXPECT_EQ(MMI::PointerEvent::POINTER_ACTION_MOVE, pointerEvent->GetPointerAction());
387     inputEventListener_->OnInputEvent(pointerEvent);
388 
389     pointerEvent->pointers_.clear();
390     pointerEvent->SetDispatchTimes(10);
391     inputEventListener_->OnInputEvent(pointerEvent);
392 
393     pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_DOWN);
394     inputEventListener_->OnInputEvent(pointerEvent);
395     pointerEvent->AddPointerItem(item);
396     inputEventListener_->OnInputEvent(pointerEvent);
397 }
398 }
399 }
400 }