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