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 "input_manager_util.h"
17 
18 #include "event_util_test.h"
19 #include "input_event.h"
20 #include "key_event.h"
21 #include "pointer_event.h"
22 
23 #undef MMI_LOG_TAG
24 #define MMI_LOG_TAG "InputManagerUtil"
25 
26 namespace OHOS {
27 namespace MMI {
28 namespace {
29 constexpr int32_t TIME_WAIT_FOR_OP { 100 };
30 constexpr int32_t NANOSECOND_TO_MILLISECOND { 1000000 };
31 constexpr int32_t DEFAULT_POINTER_ID { 0 };
32 constexpr int32_t DEFAULT_DEVICE_ID { 0 };
33 constexpr int32_t INDEX_FIRST { 1 };
34 constexpr int32_t INDEX_SECOND { 2 };
35 constexpr int32_t INDEX_THIRD { 3 };
36 constexpr int32_t MOUSE_ICON_SIZE { 64 };
37 constexpr int32_t POINTER_ITEM_DISPLAY_X_OFFSET_2 { 50 };
38 constexpr int32_t POINTER_ITEM_DISPLAY_X_OFFSET_3 { 53 };
39 constexpr int32_t POINTER_ITEM_DISPLAY_X_OFFSET_4 { 200 };
40 constexpr int32_t POINTER_ITEM_DISPLAY_X_OFFSET_5 { 503 };
41 constexpr int32_t POINTER_ITEM_DISPLAY_X_OFFSET_6 { 520 };
42 constexpr int32_t POINTER_ITEM_DISPLAY_X_OFFSET_7 { 523 };
43 constexpr int32_t POINTER_ITEM_DISPLAY_X_OFFSET_8 { 550 };
44 constexpr int32_t POINTER_ITEM_DISPLAY_X_OFFSET_9 { 593 };
45 constexpr int32_t POINTER_ITEM_DISPLAY_X_OFFSET_10 { 600 };
46 constexpr int32_t POINTER_ITEM_DISPLAY_X_OFFSET_11 { 610 };
47 constexpr int32_t POINTER_ITEM_DISPLAY_X_OFFSET_12 { 623 };
48 constexpr int32_t POINTER_ITEM_DISPLAY_X_OFFSET_13 { 10 };
49 constexpr int32_t POINTER_ITEM_DISPLAY_X_OFFSET_15 { 40 };
50 constexpr int32_t POINTER_ITEM_DISPLAY_X_OFFSET_16 { 546 };
51 constexpr int32_t POINTER_ITEM_DISPLAY_X_OFFSET_17 { 555 };
52 constexpr int32_t POINTER_ITEM_DISPLAY_X_OFFSET_18 { 888 };
53 constexpr int32_t POINTER_ITEM_DISPLAY_Y_OFFSET_1 { 10 };
54 constexpr int32_t POINTER_ITEM_DISPLAY_Y_OFFSET_2 { 50 };
55 constexpr int32_t POINTER_ITEM_DISPLAY_Y_OFFSET_3 { 60 };
56 constexpr int32_t POINTER_ITEM_DISPLAY_Y_OFFSET_4 { 68 };
57 constexpr int32_t POINTER_ITEM_DISPLAY_Y_OFFSET_5 { 80 };
58 constexpr int32_t POINTER_ITEM_DISPLAY_Y_OFFSET_6 { 200 };
59 constexpr int32_t POINTER_ITEM_DISPLAY_Y_OFFSET_7 { 504 };
60 constexpr int32_t POINTER_ITEM_DISPLAY_Y_OFFSET_8 { 530 };
61 constexpr int32_t POINTER_ITEM_DISPLAY_Y_OFFSET_9 { 555 };
62 constexpr int32_t POINTER_ITEM_DISPLAY_Y_OFFSET_10 { 610 };
63 constexpr int32_t POINTER_ITEM_DISPLAY_Y_OFFSET_11 { 650 };
64 constexpr int32_t POINTER_ITEM_DISPLAY_Y_OFFSET_12 { 703 };
65 constexpr int32_t POINTER_ITEM_DISPLAY_Y_OFFSET_13 { 723 };
66 constexpr int32_t POINTER_ITEM_DISPLAY_Y_OFFSET_14 { 733 };
67 constexpr int32_t POINTER_ITEM_DISPLAY_Y_OFFSET_15 { 777 };
68 constexpr int32_t POINTER_ITEM_DISPLAY_Y_OFFSET_16 { 783 };
69 constexpr int32_t POINTER_ITEM_DISPLAY_Y_OFFSET_17 { 823 };
70 constexpr int32_t POINTER_ITEM_DISPLAY_Y_OFFSET_18 { 910 };
71 constexpr int32_t POINTER_ITEM_DISPLAY_Y_OFFSET_19 { 999 };
72 constexpr int32_t POINTER_ITEM_DISPLAY_Y_OFFSET_20 { 1259 };
73 constexpr int32_t POINTER_ITEM_WIDTH_OFFSET_1 { 20 };
74 constexpr int32_t POINTER_ITEM_WIDTH_OFFSET_2 { 50 };
75 constexpr int32_t POINTER_ITEM_WIDTH_OFFSET_3 { 80 };
76 constexpr int32_t POINTER_ITEM_HEIGHT_OFFSET_1 { 60 };
77 constexpr int32_t POINTER_ITEM_HEIGHT_OFFSET_2 { 80 };
78 constexpr int32_t POINTER_ITEM_WINDOW_X_OFFSET_1 { 20 };
79 constexpr int32_t POINTER_ITEM_WINDOW_X_OFFSET_2 { 55 };
80 constexpr int32_t POINTER_ITEM_WINDOW_X_OFFSET_3 { 67 };
81 constexpr int32_t POINTER_ITEM_WINDOW_X_OFFSET_4 { 70 };
82 constexpr int32_t POINTER_ITEM_WINDOW_X_OFFSET_5 { 80 };
83 constexpr int32_t POINTER_ITEM_WINDOW_X_OFFSET_6 { 120 };
84 constexpr int32_t POINTER_ITEM_WINDOW_X_OFFSET_7 { 300 };
85 constexpr int32_t POINTER_ITEM_WINDOW_X_OFFSET_8 { 323 };
86 constexpr int32_t POINTER_ITEM_WINDOW_X_OFFSET_9 { 701 };
87 constexpr int32_t POINTER_ITEM_WINDOW_X_OFFSET_10 { 720 };
88 constexpr int32_t POINTER_ITEM_WINDOW_X_OFFSET_11 { 740 };
89 constexpr int32_t POINTER_ITEM_WINDOW_Y_OFFSET_1 { 45 };
90 constexpr int32_t POINTER_ITEM_WINDOW_Y_OFFSET_2 { 66 };
91 constexpr int32_t POINTER_ITEM_WINDOW_Y_OFFSET_3 { 70 };
92 constexpr int32_t POINTER_ITEM_WINDOW_Y_OFFSET_4 { 90 };
93 constexpr int32_t POINTER_ITEM_WINDOW_Y_OFFSET_5 { 99 };
94 constexpr int32_t POINTER_ITEM_WINDOW_Y_OFFSET_6 { 106 };
95 constexpr int32_t POINTER_ITEM_WINDOW_Y_OFFSET_7 { 300 };
96 constexpr int32_t POINTER_ITEM_WINDOW_Y_OFFSET_8 { 453 };
97 constexpr int32_t POINTER_ITEM_WINDOW_Y_OFFSET_9 { 702 };
98 constexpr int32_t POINTER_ITEM_WINDOW_Y_OFFSET_10 { 730 };
99 constexpr int32_t POINTER_ITEM_WINDOW_Y_OFFSET_11 { 750 };
100 constexpr double POINTER_ITEM_PRESSURE_OFFSET_1 { 5.0 };
101 constexpr double POINTER_ITEM_PRESSURE_OFFSET_2 { 7.0 };
102 constexpr double POINTER_ITEM_PRESSURE_OFFSET_3 { 0.15 };
103 constexpr double POINTER_ITEM_PRESSURE_OFFSET_4 { 0.45 };
104 constexpr double POINTER_ITEM_PRESSURE_OFFSET_5 { 0.7 };
105 constexpr double POINTER_AXIS_VALUE_OFFSET_1 { -1.0000 };
106 constexpr double POINTER_AXIS_VALUE_OFFSET_2 { 30.0 };
107 constexpr double POINTER_AXIS_VALUE_OFFSET_3 { 40.0 };
108 constexpr double POINTER_ITEM_TITLE_X_OFFSET_1 { 2.12 };
109 constexpr double POINTER_ITEM_TITLE_X_OFFSET_2 { 12.22 };
110 constexpr double POINTER_ITEM_TITLE_X_OFFSET_3 { 10.0 };
111 constexpr double POINTER_ITEM_TITLE_Y_OFFSET_1 { 5.43 };
112 constexpr double POINTER_ITEM_TITLE_Y_OFFSET_2 { 15.33 };
113 constexpr double POINTER_ITEM_TITLE_Y_OFFSET_3 { -9.0 };
114 constexpr int32_t POINTER_ITEM_ID_INVALID { -1 };
115 constexpr int32_t POINTER_ITEM_ID_ONE { 1 };
116 constexpr int32_t POINTER_ITEM_ID_TWO { 2 };
117 constexpr int32_t POINTER_ITEM_ID_FOUR { 4 };
118 } // namespace
119 
InitOption(const std::set<int32_t> & preKeys,int32_t finalKey,bool isFinalKeyDown,int32_t duration)120 std::shared_ptr<KeyOption> InputManagerUtil::InitOption(
121     const std::set<int32_t> &preKeys, int32_t finalKey, bool isFinalKeyDown, int32_t duration)
122 {
123     std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>();
124     keyOption->SetFinalKeyDown(isFinalKeyDown);
125     keyOption->SetFinalKey(finalKey);
126     keyOption->SetPreKeys(preKeys);
127     keyOption->SetFinalKeyDownDuration(duration);
128     return keyOption;
129 }
130 
SetupPointerEvent001()131 std::shared_ptr<PointerEvent> InputManagerUtil::SetupPointerEvent001()
132 {
133     auto pointerEvent = PointerEvent::Create();
134     CHKPP(pointerEvent);
135     PointerEvent::PointerItem item;
136     item.SetPointerId(0);
137     item.SetDisplayX(POINTER_ITEM_DISPLAY_X_OFFSET_7);
138     item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_OFFSET_13);
139     item.SetPressure(POINTER_ITEM_PRESSURE_OFFSET_1);
140     item.SetDeviceId(1);
141     pointerEvent->AddPointerItem(item);
142 
143     item.SetPointerId(1);
144     item.SetDisplayX(POINTER_ITEM_DISPLAY_X_OFFSET_11);
145     item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_OFFSET_18);
146     item.SetPressure(POINTER_ITEM_PRESSURE_OFFSET_2);
147     item.SetDeviceId(1);
148     pointerEvent->AddPointerItem(item);
149 
150     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
151     pointerEvent->SetPointerId(1);
152     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
153     return pointerEvent;
154 }
155 
SetupPointerEvent002()156 std::shared_ptr<PointerEvent> InputManagerUtil::SetupPointerEvent002()
157 {
158     auto pointerEvent = PointerEvent::Create();
159     CHKPP(pointerEvent);
160     PointerEvent::PointerItem item;
161     item.SetPointerId(0);
162     item.SetDisplayX(POINTER_ITEM_DISPLAY_X_OFFSET_9);
163     item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_OFFSET_16);
164     item.SetPressure(POINTER_ITEM_PRESSURE_OFFSET_1);
165     item.SetDeviceId(1);
166     pointerEvent->AddPointerItem(item);
167 
168     item.SetPointerId(1);
169     item.SetDisplayX(POINTER_ITEM_DISPLAY_X_OFFSET_10);
170     item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_OFFSET_10);
171     item.SetPressure(POINTER_ITEM_PRESSURE_OFFSET_2);
172     item.SetDeviceId(1);
173     pointerEvent->AddPointerItem(item);
174 
175     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
176     pointerEvent->SetPointerId(1);
177     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
178     return pointerEvent;
179 }
180 
SetupPointerEvent003()181 std::shared_ptr<PointerEvent> InputManagerUtil::SetupPointerEvent003()
182 {
183     auto pointerEvent = PointerEvent::Create();
184     CHKPP(pointerEvent);
185     PointerEvent::PointerItem item;
186     item.SetPointerId(0);
187     item.SetDisplayX(POINTER_ITEM_DISPLAY_X_OFFSET_3);
188     item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_OFFSET_14);
189     item.SetPressure(POINTER_ITEM_PRESSURE_OFFSET_1);
190     item.SetDeviceId(1);
191     pointerEvent->AddPointerItem(item);
192 
193     item.SetPointerId(1);
194     item.SetDisplayX(POINTER_ITEM_DISPLAY_X_OFFSET_12);
195     item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_OFFSET_17);
196     item.SetPressure(0);
197     item.SetDeviceId(1);
198     pointerEvent->AddPointerItem(item);
199 
200     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
201     pointerEvent->SetPointerId(1);
202     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
203     return pointerEvent;
204 }
205 
SetupPointerEvent005()206 std::shared_ptr<PointerEvent> InputManagerUtil::SetupPointerEvent005()
207 {
208     auto pointerEvent = PointerEvent::Create();
209     CHKPP(pointerEvent);
210     int64_t downTime = GetNanoTime() / NANOSECOND_TO_MILLISECOND;
211     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
212     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_BUTTON_DOWN);
213     pointerEvent->SetButtonId(PointerEvent::MOUSE_BUTTON_LEFT);
214     pointerEvent->SetPointerId(0);
215     pointerEvent->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
216     PointerEvent::PointerItem item;
217     item.SetPointerId(0);
218     item.SetDownTime(downTime);
219     item.SetPressed(true);
220 
221     item.SetDisplayX(POINTER_ITEM_DISPLAY_X_OFFSET_6);
222     item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_OFFSET_8);
223     item.SetWindowX(POINTER_ITEM_WINDOW_X_OFFSET_11);
224     item.SetWindowY(POINTER_ITEM_WINDOW_Y_OFFSET_11);
225 
226     item.SetWidth(0);
227     item.SetHeight(0);
228     item.SetPressure(0);
229     item.SetDeviceId(0);
230     pointerEvent->AddPointerItem(item);
231     return pointerEvent;
232 }
233 
SetupPointerEvent006()234 std::shared_ptr<PointerEvent> InputManagerUtil::SetupPointerEvent006()
235 {
236     auto pointerEvent = PointerEvent::Create();
237     CHKPP(pointerEvent);
238     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
239     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
240     pointerEvent->SetPointerId(0);
241     PointerEvent::PointerItem item;
242     item.SetPressed(false);
243     item.SetPointerId(0);
244     item.SetDownTime(0);
245     item.SetDisplayX(POINTER_ITEM_DISPLAY_X_OFFSET_4);
246     item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_OFFSET_4);
247     item.SetWindowX(POINTER_ITEM_WINDOW_X_OFFSET_3);
248     item.SetWindowY(POINTER_ITEM_WINDOW_Y_OFFSET_5);
249 
250     item.SetWidth(POINTER_ITEM_WIDTH_OFFSET_2);
251     item.SetPressure(0);
252     item.SetDeviceId(0);
253     item.SetHeight(POINTER_ITEM_HEIGHT_OFFSET_1);
254     pointerEvent->AddPointerItem(item);
255     return pointerEvent;
256 }
257 
SetupPointerEvent007()258 std::shared_ptr<PointerEvent> InputManagerUtil::SetupPointerEvent007()
259 {
260     auto pointerEvent = PointerEvent::Create();
261     CHKPP(pointerEvent);
262     int64_t downTime = GetNanoTime() / NANOSECOND_TO_MILLISECOND;
263     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
264     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_BUTTON_UP);
265     pointerEvent->SetButtonId(PointerEvent::MOUSE_BUTTON_LEFT);
266     pointerEvent->SetPointerId(0);
267     pointerEvent->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
268     PointerEvent::PointerItem item;
269     item.SetPointerId(0);
270     item.SetDownTime(downTime);
271     item.SetPressed(false);
272     item.SetDisplayX(POINTER_ITEM_DISPLAY_X_OFFSET_8);
273     item.SetWindowX(POINTER_ITEM_WINDOW_X_OFFSET_10);
274     item.SetWindowY(POINTER_ITEM_WINDOW_Y_OFFSET_10);
275     item.SetWidth(POINTER_ITEM_WIDTH_OFFSET_3);
276     item.SetHeight(POINTER_ITEM_HEIGHT_OFFSET_2);
277     item.SetPressure(0);
278     item.SetDeviceId(0);
279     item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_OFFSET_11);
280     pointerEvent->AddPointerItem(item);
281     return pointerEvent;
282 }
283 
SetupPointerEvent009()284 std::shared_ptr<PointerEvent> InputManagerUtil::SetupPointerEvent009()
285 {
286     auto pointerEvent = PointerEvent::Create();
287     CHKPP(pointerEvent);
288     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
289     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_AXIS_UPDATE);
290     pointerEvent->SetPointerId(1);
291     pointerEvent->SetAxisValue(PointerEvent::AXIS_TYPE_SCROLL_VERTICAL, POINTER_AXIS_VALUE_OFFSET_1);
292     PointerEvent::PointerItem item;
293     item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_OFFSET_7);
294     item.SetDownTime(0);
295     item.SetPressed(false);
296     item.SetDisplayX(POINTER_ITEM_DISPLAY_X_OFFSET_5);
297     item.SetWindowX(POINTER_ITEM_WINDOW_X_OFFSET_9);
298     item.SetPointerId(1);
299     item.SetWindowY(POINTER_ITEM_WINDOW_Y_OFFSET_9);
300     item.SetDeviceId(0);
301     item.SetWidth(POINTER_ITEM_WIDTH_OFFSET_1);
302     item.SetHeight(POINTER_ITEM_HEIGHT_OFFSET_1);
303     item.SetPressure(0);
304     pointerEvent->AddPointerItem(item);
305     return pointerEvent;
306 }
307 
SetupPointerEvent010()308 std::shared_ptr<PointerEvent> InputManagerUtil::SetupPointerEvent010()
309 {
310     auto pointerEvent = PointerEvent::Create();
311     CHKPP(pointerEvent);
312     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
313     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_AXIS_UPDATE);
314     pointerEvent->SetPointerId(1);
315     pointerEvent->SetAxisValue(PointerEvent::AXIS_TYPE_SCROLL_VERTICAL, POINTER_AXIS_VALUE_OFFSET_2);
316     pointerEvent->SetAxisValue(PointerEvent::AXIS_TYPE_SCROLL_HORIZONTAL, POINTER_AXIS_VALUE_OFFSET_3);
317     PointerEvent::PointerItem item;
318     item.SetPointerId(1);
319     item.SetDownTime(0);
320     item.SetPressed(false);
321 
322     item.SetDisplayX(POINTER_ITEM_DISPLAY_X_OFFSET_4);
323     item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_OFFSET_6);
324     item.SetWindowX(POINTER_ITEM_WINDOW_X_OFFSET_7);
325     item.SetWindowY(POINTER_ITEM_WINDOW_Y_OFFSET_7);
326 
327     item.SetWidth(0);
328     item.SetHeight(0);
329     item.SetPressure(0);
330     item.SetDeviceId(0);
331     pointerEvent->AddPointerItem(item);
332     return pointerEvent;
333 }
334 
SetupPointerEvent011()335 std::shared_ptr<PointerEvent> InputManagerUtil::SetupPointerEvent011()
336 {
337     auto pointerEvent = PointerEvent::Create();
338     CHKPP(pointerEvent);
339     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
340     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
341     pointerEvent->SetPointerId(1);
342     PointerEvent::PointerItem item;
343     item.SetTiltY(POINTER_ITEM_TITLE_Y_OFFSET_1);
344     item.SetPointerId(0);
345     item.SetDownTime(0);
346     item.SetWindowY(POINTER_ITEM_WINDOW_Y_OFFSET_8);
347     item.SetDisplayX(POINTER_ITEM_DISPLAY_X_OFFSET_7);
348     item.SetWindowX(POINTER_ITEM_WINDOW_X_OFFSET_8);
349     item.SetHeight(0);
350     item.SetTiltX(POINTER_ITEM_TITLE_X_OFFSET_1);
351     item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_OFFSET_13);
352     item.SetPressure(POINTER_ITEM_PRESSURE_OFFSET_3);
353     item.SetDeviceId(1);
354     item.SetWidth(0);
355     pointerEvent->AddPointerItem(item);
356 
357     item.SetDownTime(0);
358     item.SetPointerId(1);
359     item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_OFFSET_4);
360     item.SetWindowX(POINTER_ITEM_WINDOW_X_OFFSET_4);
361     item.SetWidth(0);
362     item.SetDeviceId(1);
363     item.SetHeight(0);
364     item.SetDisplayX(POINTER_ITEM_DISPLAY_X_OFFSET_4);
365     item.SetTiltX(POINTER_ITEM_TITLE_X_OFFSET_2);
366     item.SetTiltY(POINTER_ITEM_TITLE_Y_OFFSET_2);
367     item.SetPressure(POINTER_ITEM_PRESSURE_OFFSET_4);
368     item.SetWindowY(POINTER_ITEM_WINDOW_Y_OFFSET_3);
369     pointerEvent->AddPointerItem(item);
370     return pointerEvent;
371 }
372 
SetupPointerEvent012()373 std::shared_ptr<PointerEvent> InputManagerUtil::SetupPointerEvent012()
374 {
375     auto pointerEvent = PointerEvent::Create();
376     CHKPP(pointerEvent);
377     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
378     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
379     pointerEvent->SetPointerId(1);
380     PointerEvent::PointerItem item;
381     item.SetDeviceId(1);
382     item.SetTiltY(POINTER_ITEM_TITLE_Y_OFFSET_1);
383     item.SetHeight(0);
384     item.SetDownTime(0);
385     item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_OFFSET_13);
386     item.SetWindowX(POINTER_ITEM_WINDOW_X_OFFSET_8);
387     item.SetDisplayX(POINTER_ITEM_DISPLAY_X_OFFSET_7);
388     item.SetWindowY(POINTER_ITEM_WINDOW_Y_OFFSET_8);
389     item.SetWidth(0);
390     item.SetTiltX(POINTER_ITEM_TITLE_X_OFFSET_1);
391     item.SetPressure(POINTER_ITEM_PRESSURE_OFFSET_3);
392     item.SetPointerId(0);
393     pointerEvent->AddPointerItem(item);
394 
395     item.SetDeviceId(1);
396     item.SetDownTime(0);
397     item.SetTiltX(POINTER_ITEM_TITLE_X_OFFSET_2);
398     item.SetWindowX(POINTER_ITEM_WINDOW_X_OFFSET_4);
399     item.SetWindowY(POINTER_ITEM_WINDOW_Y_OFFSET_3);
400     item.SetWidth(0);
401     item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_OFFSET_4);
402     item.SetHeight(0);
403     item.SetDisplayX(POINTER_ITEM_DISPLAY_X_OFFSET_4);
404     item.SetTiltY(POINTER_ITEM_TITLE_Y_OFFSET_2);
405     item.SetPressure(POINTER_ITEM_PRESSURE_OFFSET_4);
406     item.SetPointerId(1);
407     pointerEvent->AddPointerItem(item);
408     return pointerEvent;
409 }
410 
SetupPointerEvent013()411 std::shared_ptr<PointerEvent> InputManagerUtil::SetupPointerEvent013()
412 {
413     auto pointerEvent = PointerEvent::Create();
414     CHKPP(pointerEvent);
415     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
416     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
417     pointerEvent->SetPointerId(1);
418     PointerEvent::PointerItem item;
419     item.SetPointerId(0);
420     item.SetDownTime(0);
421     item.SetDisplayX(POINTER_ITEM_DISPLAY_X_OFFSET_7);
422     item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_OFFSET_13);
423     item.SetWindowX(POINTER_ITEM_WINDOW_X_OFFSET_8);
424     item.SetWindowY(POINTER_ITEM_WINDOW_Y_OFFSET_8);
425     item.SetWidth(0);
426     item.SetHeight(0);
427     item.SetTiltX(POINTER_ITEM_TITLE_X_OFFSET_1);
428     item.SetTiltY(POINTER_ITEM_TITLE_Y_OFFSET_1);
429     item.SetPressure(POINTER_ITEM_PRESSURE_OFFSET_3);
430     item.SetDeviceId(1);
431     pointerEvent->AddPointerItem(item);
432 
433     item.SetPointerId(1);
434     item.SetDownTime(0);
435     item.SetDisplayX(POINTER_ITEM_DISPLAY_X_OFFSET_4);
436     item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_OFFSET_4);
437     item.SetWindowX(POINTER_ITEM_WINDOW_X_OFFSET_4);
438     item.SetWindowY(POINTER_ITEM_WINDOW_Y_OFFSET_3);
439     item.SetWidth(0);
440     item.SetHeight(0);
441     item.SetTiltX(POINTER_ITEM_TITLE_X_OFFSET_2);
442     item.SetTiltY(POINTER_ITEM_TITLE_Y_OFFSET_2);
443     item.SetPressure(POINTER_ITEM_PRESSURE_OFFSET_4);
444     item.SetDeviceId(1);
445     pointerEvent->AddPointerItem(item);
446     return pointerEvent;
447 }
448 
SetupPointerEvent014()449 std::shared_ptr<PointerEvent> InputManagerUtil::SetupPointerEvent014()
450 {
451     auto pointerEvent = PointerEvent::Create();
452     CHKPP(pointerEvent);
453     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
454     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
455     pointerEvent->SetPointerId(0);
456     PointerEvent::PointerItem item;
457     item.SetDisplayX(POINTER_ITEM_DISPLAY_X_OFFSET_4);
458     item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_OFFSET_9);
459     item.SetWindowX(POINTER_ITEM_WINDOW_X_OFFSET_1);
460     item.SetWindowY(POINTER_ITEM_WINDOW_Y_OFFSET_1);
461 
462     item.SetWidth(0);
463     item.SetHeight(0);
464     item.SetPressed(false);
465     item.SetPointerId(0);
466     item.SetDownTime(0);
467     item.SetPressure(0);
468     item.SetDeviceId(0);
469     pointerEvent->AddPointerItem(item);
470     return pointerEvent;
471 }
472 
SetupPointerEvent015()473 std::shared_ptr<PointerEvent> InputManagerUtil::SetupPointerEvent015()
474 {
475     auto pointerEvent = PointerEvent::Create();
476     CHKPP(pointerEvent);
477     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
478     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
479     pointerEvent->SetPointerId(0);
480     PointerEvent::PointerItem item;
481     item.SetPointerId(0);
482     item.SetHeight(0);
483     item.SetPressure(0);
484     item.SetWidth(0);
485     item.SetDeviceId(0);
486     item.SetDownTime(0);
487     item.SetPressed(false);
488 
489     item.SetDisplayX(POINTER_ITEM_DISPLAY_X_OFFSET_4);
490     item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_OFFSET_20);
491     item.SetWindowX(POINTER_ITEM_WINDOW_X_OFFSET_6);
492     item.SetWindowY(POINTER_ITEM_WINDOW_Y_OFFSET_6);
493 
494     pointerEvent->AddPointerItem(item);
495     return pointerEvent;
496 }
497 
498 #ifdef OHOS_BUILD_ENABLE_JOYSTICK
SetupPointerEvent016()499 std::shared_ptr<PointerEvent> InputManagerUtil::SetupPointerEvent016()
500 {
501     auto pointerEvent = PointerEvent::Create();
502     CHKPP(pointerEvent);
503     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_JOYSTICK);
504     return pointerEvent;
505 }
506 #endif  // OHOS_BUILD_ENABLE_JOYSTICK
507 
SetupMouseEvent001()508 std::shared_ptr<PointerEvent> InputManagerUtil::SetupMouseEvent001()
509 {
510     auto pointerEvent = PointerEvent::Create();
511     CHKPP(pointerEvent);
512     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
513     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
514     pointerEvent->SetPointerId(0);
515     PointerEvent::PointerItem item;
516 
517     item.SetDisplayX(POINTER_ITEM_DISPLAY_X_OFFSET_2);
518     item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_OFFSET_5);
519     item.SetWidth(0);
520     item.SetHeight(0);
521     item.SetPressure(0);
522     item.SetDeviceId(0);
523     item.SetWindowX(POINTER_ITEM_WINDOW_X_OFFSET_2);
524     item.SetWindowY(POINTER_ITEM_WINDOW_Y_OFFSET_2);
525     item.SetPointerId(0);
526     item.SetDownTime(0);
527     item.SetPressed(false);
528 
529     pointerEvent->AddPointerItem(item);
530     return pointerEvent;
531 }
532 
SetupMouseEvent002()533 std::shared_ptr<PointerEvent> InputManagerUtil::SetupMouseEvent002()
534 {
535     auto pointerEvent = PointerEvent::Create();
536     CHKPP(pointerEvent);
537     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
538     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
539     pointerEvent->SetPointerId(0);
540     PointerEvent::PointerItem item;
541     item.SetDownTime(0);
542     item.SetPressed(false);
543     item.SetDisplayX(POINTER_ITEM_DISPLAY_X_OFFSET_15);
544     item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_OFFSET_3);
545     item.SetWidth(0);
546     item.SetHeight(0);
547     item.SetWindowX(POINTER_ITEM_WINDOW_X_OFFSET_5);
548     item.SetWindowY(POINTER_ITEM_WINDOW_Y_OFFSET_4);
549     item.SetPressure(0);
550     item.SetPointerId(0);
551     item.SetDeviceId(0);
552     pointerEvent->AddPointerItem(item);
553     return pointerEvent;
554 }
555 
SetupTouchScreenEvent001()556 std::shared_ptr<PointerEvent> InputManagerUtil::SetupTouchScreenEvent001()
557 {
558     auto pointerEvent = PointerEvent::Create();
559     CHKPP(pointerEvent);
560     PointerEvent::PointerItem item;
561     item.SetPointerId(0);
562     item.SetDisplayX(POINTER_ITEM_DISPLAY_X_OFFSET_13);
563     item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_OFFSET_1);
564     item.SetPressure(POINTER_ITEM_PRESSURE_OFFSET_1);
565     item.SetDeviceId(1);
566     pointerEvent->AddPointerItem(item);
567     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
568     pointerEvent->SetPointerId(0);
569     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
570     return pointerEvent;
571 }
572 
SetupTouchScreenEvent002()573 std::shared_ptr<PointerEvent> InputManagerUtil::SetupTouchScreenEvent002()
574 {
575     auto pointerEvent = PointerEvent::Create();
576     CHKPP(pointerEvent);
577     PointerEvent::PointerItem item;
578     item.SetPointerId(0);
579     item.SetDisplayX(POINTER_ITEM_DISPLAY_X_OFFSET_2);
580     item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_OFFSET_2);
581     item.SetPressure(POINTER_ITEM_PRESSURE_OFFSET_1);
582     item.SetDeviceId(1);
583     pointerEvent->AddPointerItem(item);
584     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
585     pointerEvent->SetPointerId(0);
586     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
587     return pointerEvent;
588 }
589 
SetPointerItem(PointerEvent::PointerItem & item,int32_t pointerId)590 void InputManagerUtil::SetPointerItem(PointerEvent::PointerItem &item, int32_t pointerId)
591 {
592     item.SetPointerId(pointerId);
593     item.SetDisplayX(POINTER_ITEM_DISPLAY_X_OFFSET_2);
594     item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_OFFSET_2);
595     item.SetPressure(POINTER_ITEM_PRESSURE_OFFSET_1);
596     item.SetDeviceId(1);
597 }
598 
SetupSimulateEvent001()599 std::shared_ptr<PointerEvent> InputManagerUtil::SetupSimulateEvent001()
600 {
601     auto pointerEvent = PointerEvent::Create();
602     CHKPP(pointerEvent);
603 
604     PointerEvent::PointerItem item;
605     SetPointerItem(item, POINTER_ITEM_ID_ONE);
606     pointerEvent->AddPointerItem(item);
607 
608     SetPointerItem(item, POINTER_ITEM_ID_TWO);
609     pointerEvent->AddPointerItem(item);
610 
611     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
612     pointerEvent->SetPointerId(POINTER_ITEM_ID_ONE);
613     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
614     return pointerEvent;
615 }
616 
SetupSimulateEvent002()617 std::shared_ptr<PointerEvent> InputManagerUtil::SetupSimulateEvent002()
618 {
619     auto pointerEvent = PointerEvent::Create();
620     CHKPP(pointerEvent);
621 
622     PointerEvent::PointerItem item;
623     SetPointerItem(item, POINTER_ITEM_ID_TWO);
624     pointerEvent->AddPointerItem(item);
625 
626     SetPointerItem(item, POINTER_ITEM_ID_INVALID);
627     pointerEvent->AddPointerItem(item);
628 
629     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
630     pointerEvent->SetPointerId(POINTER_ITEM_ID_TWO);
631     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
632     return pointerEvent;
633 }
634 
SetupSimulateEvent003()635 std::shared_ptr<PointerEvent> InputManagerUtil::SetupSimulateEvent003()
636 {
637     auto pointerEvent = PointerEvent::Create();
638     CHKPP(pointerEvent);
639 
640     PointerEvent::PointerItem item;
641     SetPointerItem(item, POINTER_ITEM_ID_INVALID);
642     pointerEvent->AddPointerItem(item);
643 
644     SetPointerItem(item, POINTER_ITEM_ID_INVALID);
645     pointerEvent->AddPointerItem(item);
646 
647     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
648     pointerEvent->SetPointerId(POINTER_ITEM_ID_INVALID);
649     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
650     return pointerEvent;
651 }
652 
SetupSimulateEvent004()653 std::shared_ptr<PointerEvent> InputManagerUtil::SetupSimulateEvent004()
654 {
655     auto pointerEvent = PointerEvent::Create();
656     CHKPP(pointerEvent);
657 
658     PointerEvent::PointerItem item;
659     SetPointerItem(item, POINTER_ITEM_ID_INVALID);
660     pointerEvent->AddPointerItem(item);
661 
662     SetPointerItem(item, POINTER_ITEM_ID_INVALID);
663     pointerEvent->AddPointerItem(item);
664 
665     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
666     pointerEvent->SetPointerId(POINTER_ITEM_ID_FOUR);
667     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
668     return pointerEvent;
669 }
670 
SetupSimulateEvent005()671 std::shared_ptr<PointerEvent> InputManagerUtil::SetupSimulateEvent005()
672 {
673     auto pointerEvent = PointerEvent::Create();
674     CHKPP(pointerEvent);
675 
676     PointerEvent::PointerItem item;
677     SetPointerItem(item, POINTER_ITEM_ID_ONE);
678     pointerEvent->AddPointerItem(item);
679 
680     SetPointerItem(item, POINTER_ITEM_ID_TWO);
681     pointerEvent->AddPointerItem(item);
682 
683     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
684     pointerEvent->SetPointerId(POINTER_ITEM_ID_INVALID);
685     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
686     return pointerEvent;
687 }
688 
SetupSimulateEvent006()689 std::shared_ptr<PointerEvent> InputManagerUtil::SetupSimulateEvent006()
690 {
691     auto pointerEvent = PointerEvent::Create();
692     CHKPP(pointerEvent);
693 
694     PointerEvent::PointerItem item;
695     SetPointerItem(item, POINTER_ITEM_ID_INVALID);
696     pointerEvent->AddPointerItem(item);
697 
698     SetPointerItem(item, POINTER_ITEM_ID_FOUR);
699     pointerEvent->AddPointerItem(item);
700 
701     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
702     pointerEvent->SetPointerId(POINTER_ITEM_ID_FOUR);
703     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
704     return pointerEvent;
705 }
706 
SetupSimulateEvent007()707 std::shared_ptr<PointerEvent> InputManagerUtil::SetupSimulateEvent007()
708 {
709     auto pointerEvent = PointerEvent::Create();
710     CHKPP(pointerEvent);
711 
712     PointerEvent::PointerItem item;
713     SetPointerItem(item, POINTER_ITEM_ID_ONE);
714     pointerEvent->AddPointerItem(item);
715 
716     SetPointerItem(item, POINTER_ITEM_ID_INVALID);
717     pointerEvent->AddPointerItem(item);
718 
719     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
720     pointerEvent->SetPointerId(POINTER_ITEM_ID_INVALID);
721     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
722     return pointerEvent;
723 }
724 
SetupSimulateEvent008()725 std::shared_ptr<PointerEvent> InputManagerUtil::SetupSimulateEvent008()
726 {
727     auto pointerEvent = PointerEvent::Create();
728     CHKPP(pointerEvent);
729 
730     PointerEvent::PointerItem item;
731     SetPointerItem(item, POINTER_ITEM_ID_INVALID);
732     pointerEvent->AddPointerItem(item);
733 
734     SetPointerItem(item, POINTER_ITEM_ID_ONE);
735     pointerEvent->AddPointerItem(item);
736 
737     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
738     pointerEvent->SetPointerId(POINTER_ITEM_ID_ONE);
739     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
740     return pointerEvent;
741 }
742 
PrintPointerEventId(std::shared_ptr<PointerEvent> pointerEvent)743 void InputManagerUtil::PrintPointerEventId(std::shared_ptr<PointerEvent> pointerEvent)
744 {
745     MMI_HILOGI("PointerEvent pointerId:%{public}d", pointerEvent->GetPointerId());
746     auto pointerItems = pointerEvent->GetAllPointerItems();
747     auto it = pointerItems.begin();
748     int32_t count = 1;
749     for (pointerItems.begin(); it != pointerItems.end(); ++it) {
750         MMI_HILOGI("PointerItem:%{public}d, pointerId:%{public}d", count, it->GetPointerId());
751         count++;
752     }
753 }
754 
SetupKeyEvent001()755 std::shared_ptr<KeyEvent> InputManagerUtil::SetupKeyEvent001()
756 {
757     std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
758     CHKPP(keyEvent);
759     int64_t downTime = GetNanoTime() / NANOSECOND_TO_MILLISECOND;
760     KeyEvent::KeyItem kitDown;
761     kitDown.SetPressed(true);
762     kitDown.SetDownTime(downTime);
763     kitDown.SetKeyCode(KeyEvent::KEYCODE_A);
764     keyEvent->AddPressedKeyItems(kitDown);
765     keyEvent->SetKeyCode(KeyEvent::KEYCODE_A);
766     keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN);
767 
768     return keyEvent;
769 }
770 
SetupKeyEvent002()771 std::shared_ptr<KeyEvent> InputManagerUtil::SetupKeyEvent002()
772 {
773     std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
774     CHKPP(keyEvent);
775     int64_t downTime = GetNanoTime() / NANOSECOND_TO_MILLISECOND;
776     KeyEvent::KeyItem kitDown;
777     kitDown.SetKeyCode(KeyEvent::KEYCODE_A);
778     kitDown.SetPressed(true);
779     kitDown.SetDownTime(downTime);
780     keyEvent->SetKeyCode(KeyEvent::KEYCODE_A);
781     keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN);
782     keyEvent->AddPressedKeyItems(kitDown);
783 
784     return keyEvent;
785 }
786 
SetupKeyEvent003()787 std::shared_ptr<KeyEvent> InputManagerUtil::SetupKeyEvent003()
788 {
789     std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
790     CHKPP(keyEvent);
791     int64_t downTime = GetNanoTime() / NANOSECOND_TO_MILLISECOND;
792     KeyEvent::KeyItem kitDown;
793     kitDown.SetKeyCode(KeyEvent::KEYCODE_A);
794     kitDown.SetDownTime(downTime);
795     kitDown.SetPressed(true);
796     keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN);
797     keyEvent->SetKeyCode(KeyEvent::KEYCODE_A);
798     keyEvent->AddPressedKeyItems(kitDown);
799 
800     return keyEvent;
801 }
802 
TestMarkConsumedStep1()803 std::shared_ptr<PointerEvent> InputManagerUtil::TestMarkConsumedStep1()
804 {
805     auto pointerEvent = PointerEvent::Create();
806     CHKPP(pointerEvent);
807     PointerEvent::PointerItem item;
808     item.SetPointerId(0);
809     item.SetDisplayX(POINTER_ITEM_DISPLAY_X_OFFSET_7);
810     item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_OFFSET_13);
811     item.SetPressure(POINTER_ITEM_PRESSURE_OFFSET_1);
812     item.SetDeviceId(1);
813     pointerEvent->AddPointerItem(item);
814 
815     pointerEvent->SetId(std::numeric_limits<int32_t>::max() - INDEX_THIRD);
816     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
817     pointerEvent->SetPointerId(0);
818     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
819 
820 #if defined(OHOS_BUILD_ENABLE_TOUCH) && defined(OHOS_BUILD_ENABLE_MONITOR)
821     TestSimulateInputEvent(pointerEvent);
822 #endif  // OHOS_BUILD_ENABLE_TOUCH && OHOS_BUILD_ENABLE_MONITOR
823     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
824     return pointerEvent;
825 }
826 
TestMarkConsumedStep2()827 std::shared_ptr<PointerEvent> InputManagerUtil::TestMarkConsumedStep2()
828 {
829     auto pointerEvent = PointerEvent::Create();
830     CHKPP(pointerEvent);
831     PointerEvent::PointerItem item;
832     item.SetPointerId(0);
833     item.SetDisplayX(POINTER_ITEM_DISPLAY_X_OFFSET_12);
834     item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_OFFSET_13);
835     item.SetPressure(POINTER_ITEM_PRESSURE_OFFSET_1);
836     item.SetDeviceId(1);
837     pointerEvent->AddPointerItem(item);
838 
839     pointerEvent->SetId(std::numeric_limits<int32_t>::max() - INDEX_SECOND);
840     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
841     pointerEvent->SetPointerId(0);
842     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
843 
844 #if defined(OHOS_BUILD_ENABLE_TOUCH) && defined(OHOS_BUILD_ENABLE_MONITOR)
845     TestSimulateInputEvent(pointerEvent);
846 #endif  // OHOS_BUILD_ENABLE_TOUCH && OHOS_BUILD_ENABLE_MONITOR
847     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
848     return pointerEvent;
849 }
850 
TestMarkConsumedStep3(int32_t monitorId,int32_t eventId)851 void InputManagerUtil::TestMarkConsumedStep3(int32_t monitorId, int32_t eventId)
852 {
853     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
854     TestUtil->SetRecvFlag(RECV_FLAG::RECV_MARK_CONSUMED);
855     TestMarkConsumed(monitorId, eventId);
856     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
857 }
858 
TestMarkConsumedStep4()859 void InputManagerUtil::TestMarkConsumedStep4()
860 {
861     auto pointerEvent = PointerEvent::Create();
862     CHKPV(pointerEvent);
863     PointerEvent::PointerItem item;
864     item.SetDeviceId(1);
865     item.SetPointerId(0);
866     item.SetDisplayX(POINTER_ITEM_DISPLAY_X_OFFSET_17);
867     item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_OFFSET_15);
868     item.SetPressure(POINTER_ITEM_PRESSURE_OFFSET_1);
869     pointerEvent->AddPointerItem(item);
870 
871     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
872     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
873     pointerEvent->SetPointerId(0);
874     pointerEvent->SetId(std::numeric_limits<int32_t>::max() - INDEX_FIRST);
875 
876 #if defined(OHOS_BUILD_ENABLE_TOUCH) && defined(OHOS_BUILD_ENABLE_MONITOR)
877     TestSimulateInputEvent(pointerEvent, TestScene::EXCEPTION_TEST);
878 #endif  // OHOS_BUILD_ENABLE_TOUCH && OHOS_BUILD_ENABLE_MONITOR
879     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
880 }
881 
TestMarkConsumedStep5()882 void InputManagerUtil::TestMarkConsumedStep5()
883 {
884     auto pointerEvent = PointerEvent::Create();
885     CHKPV(pointerEvent);
886     PointerEvent::PointerItem item;
887     item.SetPointerId(0);
888     item.SetDisplayX(POINTER_ITEM_DISPLAY_X_OFFSET_16);
889     item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_OFFSET_12);
890     item.SetPressure(POINTER_ITEM_PRESSURE_OFFSET_1);
891     item.SetDeviceId(1);
892     pointerEvent->AddPointerItem(item);
893 
894     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
895     pointerEvent->SetId(std::numeric_limits<int32_t>::max());
896     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
897     pointerEvent->SetPointerId(0);
898 
899 #if defined(OHOS_BUILD_ENABLE_TOUCH) && defined(OHOS_BUILD_ENABLE_MONITOR)
900     TestSimulateInputEvent(pointerEvent, TestScene::EXCEPTION_TEST);
901 #endif  // OHOS_BUILD_ENABLE_TOUCH && OHOS_BUILD_ENABLE_MONITOR
902     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
903 }
904 
TestMarkConsumedStep6()905 void InputManagerUtil::TestMarkConsumedStep6()
906 {
907     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
908     auto pointerEvent = PointerEvent::Create();
909     CHKPV(pointerEvent);
910     PointerEvent::PointerItem item;
911     item.SetPointerId(0);
912     item.SetDisplayX(POINTER_ITEM_DISPLAY_X_OFFSET_18);
913     item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_OFFSET_19);
914     item.SetPressure(POINTER_ITEM_PRESSURE_OFFSET_1);
915     item.SetDeviceId(1);
916     pointerEvent->AddPointerItem(item);
917 
918     pointerEvent->SetId(std::numeric_limits<int32_t>::max());
919     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
920     pointerEvent->SetPointerId(0);
921     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
922 
923     TestUtil->SetRecvFlag(RECV_FLAG::RECV_FOCUS);
924 #if defined(OHOS_BUILD_ENABLE_TOUCH) && defined(OHOS_BUILD_ENABLE_MONITOR)
925     TestSimulateInputEvent(pointerEvent);
926 #endif  // OHOS_BUILD_ENABLE_TOUCH && OHOS_BUILD_ENABLE_MONITOR
927     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
928 }
929 
TestMarkConsumed(int32_t monitorId,int32_t eventId)930 void InputManagerUtil::TestMarkConsumed(int32_t monitorId, int32_t eventId)
931 {
932     AccessMonitor monitor;
933     InputManager::GetInstance()->MarkConsumed(monitorId, eventId);
934 }
935 
SetMouseIconTest(const std::string iconPath)936 std::unique_ptr<OHOS::Media::PixelMap> InputManagerUtil::SetMouseIconTest(const std::string iconPath)
937 {
938     CALL_DEBUG_ENTER;
939     OHOS::Media::SourceOptions opts;
940     opts.formatHint = "image/svg+xml";
941     uint32_t ret = 0;
942     auto imageSource = OHOS::Media::ImageSource::CreateImageSource(iconPath, opts, ret);
943     CHKPP(imageSource);
944     std::set<std::string> formats;
945     ret = imageSource->GetSupportedFormats(formats);
946     MMI_HILOGD("Get supported format:%{public}u", ret);
947 
948     OHOS::Media::DecodeOptions decodeOpts;
949     decodeOpts.desiredSize = {.width = MOUSE_ICON_SIZE, .height = MOUSE_ICON_SIZE};
950 
951     std::unique_ptr<OHOS::Media::PixelMap> pixelMap = imageSource->CreatePixelMap(decodeOpts, ret);
952     CHKPL(pixelMap);
953     return pixelMap;
954 }
955 
TestAddMonitor(std::shared_ptr<IInputEventConsumer> consumer)956 int32_t InputManagerUtil::TestAddMonitor(std::shared_ptr<IInputEventConsumer> consumer)
957 {
958     return InputManager::GetInstance()->AddMonitor(consumer);
959 }
960 
TestRemoveMonitor(int32_t monitorId)961 void InputManagerUtil::TestRemoveMonitor(int32_t monitorId)
962 {
963     InputManager::GetInstance()->RemoveMonitor(monitorId);
964 }
965 
TestMonitor(int32_t monitorId,std::shared_ptr<PointerEvent> pointerEvent)966 void InputManagerUtil::TestMonitor(int32_t monitorId, std::shared_ptr<PointerEvent> pointerEvent)
967 {
968 #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_MONITOR)
969     TestSimulateInputEvent(pointerEvent);
970 #endif  // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_MONITOR
971 
972     if (IsValidHandlerId(monitorId)) {
973         TestRemoveMonitor(monitorId);
974         std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
975     }
976 }
977 
TestInterceptorIdAndPointerEvent(int32_t interceptorId,std::shared_ptr<PointerEvent> pointerEvent)978 void InputManagerUtil::TestInterceptorIdAndPointerEvent(
979     int32_t interceptorId, std::shared_ptr<PointerEvent> pointerEvent)
980 {
981 #ifdef OHOS_BUILD_ENABLE_INTERCEPTOR
982     EXPECT_TRUE(IsValidHandlerId(interceptorId));
983 #else
984     EXPECT_EQ(interceptorId, ERROR_UNSUPPORT);
985 #endif  // OHOS_BUILD_ENABLE_INTERCEPTOR
986     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
987 
988 #if defined(OHOS_BUILD_ENABLE_POINTER) && defined(OHOS_BUILD_ENABLE_INTERCEPTOR)
989     SimulateInputEventUtilTest(pointerEvent);
990 #endif  // OHOS_BUILD_ENABLE_POINTER && OHOS_BUILD_ENABLE_INTERCEPTOR
991 
992     if (IsValidHandlerId(interceptorId)) {
993         InputManager::GetInstance()->RemoveInterceptor(interceptorId);
994         std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
995     }
996 }
997 
TestInterceptorId(int32_t interceptorId1,int32_t interceptorId2)998 void InputManagerUtil::TestInterceptorId(int32_t interceptorId1, int32_t interceptorId2)
999 {
1000     if (IsValidHandlerId(interceptorId1)) {
1001         InputManager::GetInstance()->RemoveInterceptor(interceptorId1);
1002         std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
1003     }
1004 
1005     if (IsValidHandlerId(interceptorId2)) {
1006         InputManager::GetInstance()->RemoveInterceptor(interceptorId2);
1007         std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP));
1008     }
1009 }
1010 
SetupTabletToolEvent001()1011 std::shared_ptr<PointerEvent> InputManagerUtil::SetupTabletToolEvent001()
1012 {
1013     auto pointerEvent = PointerEvent::Create();
1014     CHKPP(pointerEvent);
1015     PointerEvent::PointerItem item;
1016     item.SetPointerId(DEFAULT_POINTER_ID);
1017     item.SetDisplayX(POINTER_ITEM_DISPLAY_X_OFFSET_7);
1018     item.SetDisplayY(POINTER_ITEM_DISPLAY_Y_OFFSET_13);
1019     item.SetPressure(POINTER_ITEM_PRESSURE_OFFSET_5);
1020     item.SetTiltX(POINTER_ITEM_TITLE_X_OFFSET_3);
1021     item.SetTiltY(POINTER_ITEM_TITLE_Y_OFFSET_3);
1022     item.SetDeviceId(DEFAULT_DEVICE_ID);
1023     item.SetToolType(PointerEvent::TOOL_TYPE_PEN);
1024     pointerEvent->AddPointerItem(item);
1025 
1026     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
1027     pointerEvent->SetPointerId(DEFAULT_POINTER_ID);
1028     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
1029     return pointerEvent;
1030 }
1031 }  // namespace MMI
1032 }  // namespace OHOS