1 /*
2 * Copyright (c) 2021-2024 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_command.h"
17
18 #include <getopt.h>
19
20 #include <algorithm>
21 #include <chrono>
22 #include <cmath>
23 #include <cstdio>
24 #include <cstdlib>
25 #include <ctime>
26 #include <iostream>
27 #include <limits>
28 #include <thread>
29
30 #include <sys/time.h>
31 #include <unistd.h>
32
33 #include "string_ex.h"
34
35 #include "error_multimodal.h"
36 #include "event_log_helper.h"
37 #include "input_manager.h"
38 #include "mmi_log.h"
39 #include "multimodal_event_handler.h"
40 #include "util.h"
41
42 #undef MMI_LOG_TAG
43 #define MMI_LOG_TAG "InputManagerCommand"
44
45 class InputManagerCommand {
46 public:
47 int32_t ParseCommand(int32_t argc, char *argv[]);
48 int32_t ConnectService();
49 void ShowUsage();
50 private:
51 void InitializeMouseDeathStub();
52 };
53 namespace OHOS {
54 namespace MMI {
55 namespace {
56 constexpr int32_t SLEEPTIME = 20;
57 constexpr int32_t MOUSE_ID = 7;
58 constexpr int32_t JOYSTICK_BUTTON_ID = 25;
59 constexpr int32_t TWO_MORE_COMMAND = 2;
60 constexpr int32_t THREE_MORE_COMMAND = 3;
61 constexpr int32_t MAX_PRESSED_COUNT = 30;
62 constexpr int32_t ACTION_TIME = 3000;
63 constexpr int32_t BLOCK_TIME_MS = 7;
64 constexpr int32_t TIME_TRANSITION = 1000;
65 constexpr int64_t MIN_TAKTTIME_MS = 1;
66 constexpr int64_t MAX_TAKTTIME_MS = 15000;
67 constexpr int32_t DEFAULT_DELAY = 200;
68 constexpr int32_t KNUCKLE_PARAM_SIZE = 9;
69 constexpr int32_t DEFAULT_POINTER_ID_FIRST = 0;
70 constexpr int32_t TOTAL_TIME_MS = 1000;
71 constexpr int32_t BUTTON_PARAM_SIZE = 8;
72 constexpr int32_t KEY_PARAM_SIZE = 5;
73 constexpr int32_t KEY_TIME_PARAM_SIZE = 6;
74 constexpr int32_t INTERVAL_TIME_MS = 100;
75 constexpr int32_t FINGER_LOCATION_NUMS = 4;
76 constexpr int32_t MOVE_POS_ONE = 1;
77 constexpr int32_t MOVE_POS_TWO = 2;
78 constexpr int32_t MOVE_POS_THREE = 3;
79 constexpr int32_t MAX_KEEP_TIME = 60000;
80 constexpr int32_t NUM_KEEP_ARGC = 2;
81 constexpr int32_t MAX_ARGC = 18;
82 constexpr int32_t ONE_ARGC = 1;
83 constexpr int32_t TWO_ARGC = 2;
84 constexpr int32_t THREE_ARGC = 3;
85 constexpr int32_t FOUR_ARGC = 4;
86
87 enum JoystickEvent {
88 JOYSTICK_BUTTON_UP,
89 JOYSTICK_BUTTON_PRESS,
90 JOYSTICK_MOVE,
91 JOYSTICK_CLICK,
92 JOYSTICK_INTERVAL
93 };
94 struct JoystickInfo {
95 int32_t buttonId { -1 };
96 int32_t absValue { -1 };
97 int32_t taktTime { 0 };
98 PointerEvent::AxisType absType;
99 };
100 } // namespace
101
SleepAndUpdateTime(int64_t & currentTimeMs)102 void InputManagerCommand::SleepAndUpdateTime(int64_t ¤tTimeMs)
103 {
104 int64_t nowEndSysTimeMs = GetSysClockTime() / TIME_TRANSITION;
105 int64_t sleepTimeMs = BLOCK_TIME_MS - (nowEndSysTimeMs - currentTimeMs) % BLOCK_TIME_MS;
106 std::this_thread::sleep_for(std::chrono::milliseconds(sleepTimeMs));
107 currentTimeMs = nowEndSysTimeMs + sleepTimeMs;
108 }
109
NextPos(int64_t begTimeMs,int64_t curtTimeMs,int32_t totalTimeMs,int32_t begPos,int32_t endPos)110 int32_t InputManagerCommand::NextPos(int64_t begTimeMs, int64_t curtTimeMs, int32_t totalTimeMs,
111 int32_t begPos, int32_t endPos)
112 {
113 int64_t endTimeMs = 0;
114 if (!AddInt64(begTimeMs, totalTimeMs, endTimeMs)) {
115 return begPos;
116 }
117 if (curtTimeMs < begTimeMs || curtTimeMs > endTimeMs) {
118 return begPos;
119 }
120 if (totalTimeMs == 0) {
121 std::cout << "invalid totalTimeMs" << std::endl;
122 return begPos;
123 }
124 double tmpTimeMs = static_cast<double>(curtTimeMs - begTimeMs) / totalTimeMs;
125 int32_t offsetPos = std::ceil(tmpTimeMs * (endPos - begPos));
126 int32_t retPos = 0;
127 if (offsetPos == 0) {
128 return begPos;
129 } else if (offsetPos > 0) {
130 if (!AddInt32(begPos, offsetPos, retPos)) {
131 return begPos;
132 }
133 return retPos > endPos ? endPos : retPos;
134 }
135 if (!AddInt32(begPos, offsetPos, retPos)) {
136 return begPos;
137 }
138 return retPos < endPos ? endPos : retPos;
139 }
140
ParseCommand(int32_t argc,char * argv[])141 int32_t InputManagerCommand::ParseCommand(int32_t argc, char *argv[])
142 {
143 struct option headOptions[] = {
144 {"mouse", no_argument, nullptr, 'M'},
145 {"keyboard", no_argument, nullptr, 'K'},
146 {"stylus", no_argument, nullptr, 'S'},
147 {"touch", no_argument, nullptr, 'T'},
148 {"touchpad", no_argument, nullptr, 'P'},
149 {"joystick", no_argument, nullptr, 'J'},
150 {"help", no_argument, nullptr, '?'},
151 {nullptr, 0, nullptr, 0}
152 };
153
154 struct option mouseSensorOptions[] = {
155 {"move", required_argument, nullptr, 'm'},
156 {"click", required_argument, nullptr, 'c'},
157 {"double_click", required_argument, nullptr, 'b'},
158 {"down", required_argument, nullptr, 'd'},
159 {"up", required_argument, nullptr, 'u'},
160 {"scroll", required_argument, nullptr, 's'},
161 {"drag", required_argument, nullptr, 'g'},
162 {"interval", required_argument, nullptr, 'i'},
163 {nullptr, 0, nullptr, 0}
164 };
165 struct option keyboardSensorOptions[] = {
166 {"down", required_argument, nullptr, 'd'},
167 {"up", required_argument, nullptr, 'u'},
168 {"long_press", required_argument, nullptr, 'l'},
169 {"repeat", required_argument, nullptr, 'r'},
170 {"interval", required_argument, nullptr, 'i'},
171 {nullptr, 0, nullptr, 0}
172 };
173 struct option touchSensorOptions[] = {
174 {"move", required_argument, nullptr, 'm'},
175 {"down", required_argument, nullptr, 'd'},
176 {"up", required_argument, nullptr, 'u'},
177 {"click", required_argument, nullptr, 'c'},
178 {"interval", required_argument, nullptr, 'i'},
179 {"drag", required_argument, nullptr, 'g'},
180 {"knuckle", no_argument, nullptr, 'k'},
181 {nullptr, 0, nullptr, 0}
182 };
183 struct option joystickSensorOptions[] = {
184 {"move", required_argument, nullptr, 'm'},
185 {"down", required_argument, nullptr, 'd'},
186 {"up", required_argument, nullptr, 'u'},
187 {"click", required_argument, nullptr, 'c'},
188 {"interval", required_argument, nullptr, 'i'},
189 {nullptr, 0, nullptr, 0}
190 };
191 int32_t c = 0;
192 int32_t optionIndex = 0;
193 optind = 0;
194 if ((c = getopt_long(argc, argv, "JKMPST?", headOptions, &optionIndex)) != -1) {
195 switch (c) {
196 case 'M': {
197 int32_t px = 0;
198 int32_t py = 0;
199 int32_t buttonId;
200 int32_t scrollValue;
201 while ((c = getopt_long(argc, argv, "m:d:u:c:b:s:g:i:", mouseSensorOptions, &optionIndex)) != -1) {
202 switch (c) {
203 case 'm': {
204 if (argc - optind < 1) {
205 std::cout << "too few arguments to function" << std::endl;
206 return RET_ERR;
207 }
208 auto isTraceOption = [](const std::string &opt1) {
209 return opt1 == std::string("--trace");
210 };
211 auto traceMode = [isTraceOption](int32_t argCount, char *argvOffset[]) -> bool {
212 if (argCount <= 3) {
213 return false;
214 }
215 std::string arg3 = argvOffset[2];
216 if (!arg3.empty() && arg3.at(0) == '-') {
217 return false;
218 }
219 if ((argCount >= 5) && isTraceOption(std::string(argvOffset[4]))) {
220 return true;
221 }
222 if ((argCount >= 6) && isTraceOption(std::string(argvOffset[5]))) {
223 return true;
224 }
225 return false;
226 }(argc - optind + 1, &argv[optind - 1]);
227 if (!traceMode) {
228 if (!StrToInt(optarg, px) || !StrToInt(argv[optind], py)) {
229 std::cout << "invalid parameter to move mouse" << std::endl;
230 return RET_ERR;
231 }
232 if ((px < 0) || (py < 0)) {
233 std::cout << "Coordinate value must be greater or equal than 0" << std::endl;
234 return RET_ERR;
235 }
236 std::cout << "move to " << px << " " << py << std::endl;
237 auto pointerEvent = PointerEvent::Create();
238 CHKPR(pointerEvent, ERROR_NULL_POINTER);
239 PointerEvent::PointerItem item;
240 item.SetPointerId(0);
241 item.SetDisplayX(px);
242 item.SetDisplayY(py);
243 pointerEvent->AddPointerItem(item);
244 pointerEvent->SetPointerId(0);
245 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
246 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
247 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
248 optind++;
249 } else {
250 int32_t px1 = 0;
251 int32_t py1 = 0;
252 int32_t px2 = 0;
253 int32_t py2 = 0;
254 int32_t totalTimeMs = 1000;
255 bool foundTraceOption = false;
256 if (argc - optind >= 3) {
257 if ((!StrToInt(optarg, px1)) ||
258 (!StrToInt(argv[optind], py1)) ||
259 (!StrToInt(argv[optind + 1], px2)) ||
260 (!StrToInt(argv[optind + 2], py2))) {
261 std::cout << "invalid coordinate value" << std::endl;
262 return RET_ERR;
263 }
264 optind += 3;
265 }
266 if ((px1 < 0) || (py1 < 0) || (px2 < 0) || (py2 < 0)) {
267 std::cout << "Coordinate value must be greater or equal than 0" << std::endl;
268 return RET_ERR;
269 }
270 if (argc - optind >= 1) {
271 std::string arg5 = argv[optind];
272 if (!arg5.empty() && arg5.at(0) == '-') {
273 if (isTraceOption(arg5)) {
274 foundTraceOption = true;
275 } else {
276 std::cout << "invalid option, the 5th position parameter must be --trace"
277 << std::endl;
278 return RET_ERR;
279 }
280 } else if (!StrToInt(arg5, totalTimeMs)) {
281 std::cout << "invalid total times" << std::endl;
282 return RET_ERR;
283 }
284 optind++;
285 }
286 if (!foundTraceOption) {
287 if (argc - optind < 1) {
288 std::cout << "missing 6th position parameter --trace" << std::endl;
289 return RET_ERR;
290 }
291 std::string arg6 = argv[optind];
292 if (!isTraceOption(arg6)) {
293 std::cout << "invalid option, the 6th position parameter must be --trace"
294 << std::endl;
295 return RET_ERR;
296 }
297 optind++;
298 foundTraceOption = true;
299 }
300 static const int64_t minTotalTimeMs = 1;
301 static const int64_t maxTotalTimeMs = 15000;
302 if ((totalTimeMs < minTotalTimeMs) || (totalTimeMs > maxTotalTimeMs)) {
303 std::cout << "total time is out of range:"
304 << minTotalTimeMs << " <= " << totalTimeMs << " <= " << maxTotalTimeMs
305 << std::endl;
306 return RET_ERR;
307 }
308 std::cout << "start coordinate: (" << px1 << ", " << py1 << ")" << std::endl;
309 std::cout << " end coordinate: (" << px2 << ", " << py2 << ")" << std::endl;
310 std::cout << " total times: " << totalTimeMs << " ms" << std::endl;
311 std::cout << " trace mode: " << std::boolalpha << foundTraceOption << std::endl;
312 auto pointerEvent = PointerEvent::Create();
313 CHKPR(pointerEvent, ERROR_NULL_POINTER);
314 px = px1;
315 py = py1;
316 PointerEvent::PointerItem item;
317 item.SetPointerId(0);
318 item.SetDisplayX(px);
319 item.SetDisplayY(py);
320 pointerEvent->SetPointerId(0);
321 pointerEvent->AddPointerItem(item);
322 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
323 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
324 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
325
326 int64_t startTimeUs = GetSysClockTime();
327 int64_t startTimeMs = startTimeUs / TIME_TRANSITION;
328 int64_t endTimeMs = 0;
329 if (!AddInt64(startTimeMs, totalTimeMs, endTimeMs)) {
330 std::cout << "system time error" << std::endl;
331 return RET_ERR;
332 }
333 int64_t currentTimeMs = startTimeMs;
334 while (currentTimeMs < endTimeMs) {
335 item.SetDisplayX(NextPos(startTimeMs, currentTimeMs, totalTimeMs, px1, px2));
336 item.SetDisplayY(NextPos(startTimeMs, currentTimeMs, totalTimeMs, py1, py2));
337 pointerEvent->SetActionTime(currentTimeMs * TIME_TRANSITION);
338 pointerEvent->UpdatePointerItem(0, item);
339 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
340 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
341 SleepAndUpdateTime(currentTimeMs);
342 }
343
344 px = px2;
345 py = py2;
346 item.SetDisplayX(px);
347 item.SetDisplayY(py);
348 pointerEvent->SetActionTime(endTimeMs * TIME_TRANSITION);
349 pointerEvent->UpdatePointerItem(0, item);
350 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
351 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
352 }
353 break;
354 }
355 case 'd': {
356 if (!StrToInt(optarg, buttonId)) {
357 std::cout << "invalid button press command" << std::endl;
358 return EVENT_REG_FAIL;
359 }
360 if (buttonId > MOUSE_ID) {
361 std::cout << "invalid button press command" << std::endl;
362 return EVENT_REG_FAIL;
363 }
364 std::cout << "press down" << buttonId << std::endl;
365 auto pointerEvent = PointerEvent::Create();
366 CHKPR(pointerEvent, ERROR_NULL_POINTER);
367 PointerEvent::PointerItem item;
368 item.SetPointerId(0);
369 item.SetDisplayX(px);
370 item.SetDisplayY(py);
371 item.SetPressed(true);
372 pointerEvent->SetPointerId(0);
373 pointerEvent->AddPointerItem(item);
374 pointerEvent->SetButtonId(buttonId);
375 pointerEvent->SetButtonPressed(buttonId);
376 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_BUTTON_DOWN);
377 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
378 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
379 break;
380 }
381 case 'u': {
382 if (!StrToInt(optarg, buttonId)) {
383 std::cout << "invalid raise button command" << std::endl;
384 return EVENT_REG_FAIL;
385 }
386 if (buttonId > MOUSE_ID) {
387 std::cout << "invalid raise button command" << std::endl;
388 return EVENT_REG_FAIL;
389 }
390 std::cout << "lift up button " << buttonId << std::endl;
391 auto pointerEvent = PointerEvent::Create();
392 CHKPR(pointerEvent, ERROR_NULL_POINTER);
393 PointerEvent::PointerItem item;
394 item.SetPointerId(0);
395 item.SetDisplayX(px);
396 item.SetDisplayY(py);
397 item.SetPressed(false);
398 pointerEvent->SetPointerId(0);
399 pointerEvent->AddPointerItem(item);
400 pointerEvent->SetButtonPressed(buttonId);
401 pointerEvent->SetButtonId(buttonId);
402 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_BUTTON_UP);
403 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
404 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
405 break;
406 }
407 case 's': {
408 if (!StrToInt(optarg, scrollValue)) {
409 std::cout << "invalid scroll button command" << std::endl;
410 return EVENT_REG_FAIL;
411 }
412 std::cout << "scroll wheel " << scrollValue << std::endl;
413 auto pointerEvent = PointerEvent::Create();
414 CHKPR(pointerEvent, ERROR_NULL_POINTER);
415 PointerEvent::PointerItem item;
416 item.SetPointerId(0);
417 item.SetDisplayX(px);
418 item.SetDisplayY(py);
419 item.SetPressed(false);
420 int64_t time = pointerEvent->GetActionStartTime();
421 pointerEvent->SetActionTime(time + ACTION_TIME);
422 pointerEvent->SetPointerId(0);
423 pointerEvent->AddPointerItem(item);
424 pointerEvent->SetButtonPressed(buttonId);
425 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_AXIS_BEGIN);
426 pointerEvent->SetAxisValue(PointerEvent::AxisType::AXIS_TYPE_SCROLL_VERTICAL,
427 scrollValue);
428 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
429 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
430
431 time = pointerEvent->GetActionStartTime();
432 pointerEvent->SetActionTime(time + ACTION_TIME);
433 pointerEvent->SetPointerId(0);
434 pointerEvent->AddPointerItem(item);
435 pointerEvent->SetButtonPressed(buttonId);
436 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_AXIS_UPDATE);
437 pointerEvent->SetAxisValue(PointerEvent::AxisType::AXIS_TYPE_SCROLL_VERTICAL,
438 scrollValue);
439 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
440 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
441
442 time = pointerEvent->GetActionStartTime();
443 pointerEvent->SetActionTime(time + ACTION_TIME);
444 pointerEvent->SetPointerId(0);
445 pointerEvent->AddPointerItem(item);
446 pointerEvent->SetButtonPressed(buttonId);
447 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_AXIS_END);
448 pointerEvent->SetAxisValue(PointerEvent::AxisType::AXIS_TYPE_SCROLL_VERTICAL,
449 scrollValue);
450 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
451 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
452 break;
453 }
454 case 'c': {
455 if (!StrToInt(optarg, buttonId)) {
456 std::cout << "invalid click button command" << std::endl;
457 return EVENT_REG_FAIL;
458 }
459 if (buttonId > MOUSE_ID) {
460 std::cout << "invalid button press command" << std::endl;
461 return EVENT_REG_FAIL;
462 }
463 std::cout << "click " << buttonId << std::endl;
464 auto pointerEvent = PointerEvent::Create();
465 CHKPR(pointerEvent, ERROR_NULL_POINTER);
466 PointerEvent::PointerItem item;
467 item.SetDisplayY(py);
468 item.SetPressed(true);
469 item.SetPointerId(0);
470 item.SetDisplayX(px);
471 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
472 pointerEvent->AddPointerItem(item);
473 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_BUTTON_DOWN);
474 pointerEvent->SetButtonId(buttonId);
475 pointerEvent->SetButtonPressed(buttonId);
476 pointerEvent->SetPointerId(0);
477 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
478 item.SetPointerId(0);
479 item.SetPressed(false);
480 item.SetDisplayX(px);
481 item.SetDisplayY(py);
482 pointerEvent->SetPointerId(0);
483 pointerEvent->UpdatePointerItem(0, item);
484 pointerEvent->SetButtonPressed(buttonId);
485 pointerEvent->SetButtonId(buttonId);
486 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_BUTTON_UP);
487 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
488 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
489 break;
490 }
491 case 'b': {
492 int32_t pressTimeMs = 50;
493 int32_t clickIntervalTimeMs = 300;
494 static constexpr int32_t minButtonId = 0;
495 static constexpr int32_t maxButtonId = 7;
496 static constexpr int32_t minPressTimeMs = 1;
497 static constexpr int32_t maxPressTimeMs = 300;
498 static constexpr int32_t minClickIntervalTimeMs = 1;
499 static constexpr int32_t maxClickIntervalTimeMs = 450;
500 if (argc < 6 || argc > 8) {
501 std::cout << "wrong number of parameters" << std::endl;
502 return RET_ERR;
503 }
504 if (!StrToInt(optarg, px) ||
505 !StrToInt(argv[optind], py)) {
506 std::cout << "invalid coordinate value" << std::endl;
507 return RET_ERR;
508 }
509 if ((px < 0) || (py < 0)) {
510 std::cout << "Coordinate value must be greater or equal than 0" << std::endl;
511 return RET_ERR;
512 }
513 if (!StrToInt(argv[optind + 1], buttonId)) {
514 std::cout << "invalid key" << std::endl;
515 return RET_ERR;
516 }
517 if (argc >= 7) {
518 if (!StrToInt(argv[optind + 2], pressTimeMs)) {
519 std::cout << "invalid press time" << std::endl;
520 return RET_ERR;
521 }
522 }
523 if (argc == BUTTON_PARAM_SIZE) {
524 if (!StrToInt(argv[optind + 3], clickIntervalTimeMs)) {
525 std::cout << "invalid interval between hits" << std::endl;
526 return RET_ERR;
527 }
528 }
529 if ((buttonId < minButtonId) || (buttonId > maxButtonId)) {
530 std::cout << "button is out of range:" << minButtonId << " < " << buttonId << " < "
531 << maxButtonId << std::endl;
532 return RET_ERR;
533 }
534 if ((pressTimeMs < minPressTimeMs) || (pressTimeMs > maxPressTimeMs)) {
535 std::cout << "press time is out of range:" << minPressTimeMs << " ms" << " < "
536 << pressTimeMs << " < " << maxPressTimeMs << " ms" << std::endl;
537 return RET_ERR;
538 }
539 if ((clickIntervalTimeMs < minClickIntervalTimeMs) ||
540 (clickIntervalTimeMs > maxClickIntervalTimeMs)) {
541 std::cout << "click interval time is out of range:" << minClickIntervalTimeMs << " ms"
542 " < " << clickIntervalTimeMs << " < " << maxClickIntervalTimeMs << " ms"
543 << std::endl;
544 return RET_ERR;
545 }
546 std::cout << " coordinate: ("<< px << ", " << py << ")" << std::endl;
547 std::cout << " button id: " << buttonId << std::endl;
548 std::cout << " press time: " << pressTimeMs << " ms" << std::endl;
549 std::cout << "interval time: " << clickIntervalTimeMs << " ms" << std::endl;
550 auto pointerEvent = PointerEvent::Create();
551 CHKPR(pointerEvent, ERROR_NULL_POINTER);
552 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
553 PointerEvent::PointerItem item;
554 item.SetPressed(true);
555 item.SetPointerId(0);
556 item.SetDisplayX(px);
557 item.SetDisplayY(py);
558 pointerEvent->SetPointerId(0);
559 pointerEvent->SetButtonId(buttonId);
560 pointerEvent->SetButtonPressed(buttonId);
561 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_BUTTON_DOWN);
562 pointerEvent->AddPointerItem(item);
563 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
564 std::this_thread::sleep_for(std::chrono::milliseconds(pressTimeMs));
565 item.SetPressed(false);
566 pointerEvent->UpdatePointerItem(0, item);
567 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_BUTTON_UP);
568 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
569 std::this_thread::sleep_for(std::chrono::milliseconds(clickIntervalTimeMs));
570
571 item.SetPressed(true);
572 pointerEvent->UpdatePointerItem(0, item);
573 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_BUTTON_DOWN);
574 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
575 std::this_thread::sleep_for(std::chrono::milliseconds(pressTimeMs));
576 item.SetPressed(false);
577 pointerEvent->UpdatePointerItem(0, item);
578 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_BUTTON_UP);
579 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
580 break;
581 }
582 case 'g': {
583 int32_t px1 = 0;
584 int32_t py1 = 0;
585 int32_t px2 = 0;
586 int32_t py2 = 0;
587 int32_t g_buttonId = 0;
588 int32_t totalTimeMs = 1000;
589 if (argc < 7) {
590 std::cout << "argc:" << argc << std::endl;
591 std::cout << "Wrong number of parameters" << std::endl;
592 return RET_ERR;
593 }
594 if (argc >= 7) {
595 if ((!StrToInt(optarg, px1)) ||
596 (!StrToInt(argv[optind], py1)) ||
597 (!StrToInt(argv[optind + 1], px2)) ||
598 (!StrToInt(argv[optind + 2], py2))) {
599 std::cout << "Invalid coordinate value" << std::endl;
600 return RET_ERR;
601 }
602 }
603 if ((px1 < 0) || (py1 < 0) || (px2 < 0) || (py2 < 0)) {
604 std::cout << "Coordinate value must be greater or equal than 0" << std::endl;
605 return RET_ERR;
606 }
607 if (argc >= 8) {
608 if (!StrToInt(argv[optind + 3], totalTimeMs)) {
609 std::cout << "Invalid total times" << std::endl;
610 return RET_ERR;
611 }
612 }
613 static const int64_t minTotalTimeMs = 1;
614 static const int64_t maxTotalTimeMs = 15000;
615 if ((totalTimeMs < minTotalTimeMs) || (totalTimeMs > maxTotalTimeMs)) {
616 std::cout << "Total time is out of range:"
617 << minTotalTimeMs << "ms" << " <= " << totalTimeMs << "ms" << " <= "
618 << maxTotalTimeMs << "ms" << std::endl;
619 return RET_ERR;
620 }
621 std::cout << "start coordinate: (" << px1 << ", " << py1 << ")" << std::endl;
622 std::cout << " end coordinate: (" << px2 << ", " << py2 << ")" << std::endl;
623 std::cout << " total time: " << totalTimeMs << "ms" << std::endl;
624 auto pointerEvent = PointerEvent::Create();
625 CHKPR(pointerEvent, ERROR_NULL_POINTER);
626 PointerEvent::PointerItem item;
627 item.SetPointerId(0);
628 item.SetDisplayY(py1);
629 item.SetDisplayX(px1);
630 item.SetPressed(false);
631 pointerEvent->SetPointerId(0);
632 pointerEvent->AddPointerItem(item);
633 pointerEvent->SetButtonPressed(0);
634 pointerEvent->SetButtonPressed(g_buttonId);
635 pointerEvent->SetButtonId(g_buttonId);
636 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_BUTTON_DOWN);
637 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
638 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
639
640 int64_t startTimeMs = GetSysClockTime() / TIME_TRANSITION;
641 int64_t endTimeMs = 0;
642 if (!AddInt64(startTimeMs, totalTimeMs, endTimeMs)) {
643 std::cout << "System time error" << std::endl;
644 return RET_ERR;
645 }
646 int64_t currentTimeMs = startTimeMs;
647 while (currentTimeMs < endTimeMs) {
648 item.SetDisplayX(NextPos(startTimeMs, currentTimeMs, totalTimeMs, px1, px2));
649 item.SetDisplayY(NextPos(startTimeMs, currentTimeMs, totalTimeMs, py1, py2));
650 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
651 pointerEvent->UpdatePointerItem(0, item);
652 pointerEvent->SetActionTime(currentTimeMs * TIME_TRANSITION);
653 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
654 SleepAndUpdateTime(currentTimeMs);
655 }
656 item.SetDisplayY(py2);
657 item.SetDisplayX(px2);
658 pointerEvent->UpdatePointerItem(0, item);
659 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
660 pointerEvent->SetActionTime(endTimeMs * TIME_TRANSITION);
661 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
662 std::this_thread::sleep_for(std::chrono::milliseconds(BLOCK_TIME_MS));
663
664 item.SetPressed(true);
665 item.SetDisplayY(py2);
666 item.SetDisplayX(px2);
667 pointerEvent->UpdatePointerItem(0, item);
668 pointerEvent->SetActionTime(endTimeMs * TIME_TRANSITION);
669 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_BUTTON_UP);
670 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
671 break;
672 }
673 case 'i': {
674 int32_t tookTime = 0;
675 if (!StrToInt(optarg, tookTime)) {
676 std::cout << "invalid command to interval time" << std::endl;
677 return EVENT_REG_FAIL;
678 }
679 const int64_t minTaktTimeMs = 1;
680 const int64_t maxTaktTimeMs = 15000;
681 if ((minTaktTimeMs > tookTime) || (maxTaktTimeMs < tookTime)) {
682 std::cout << "tookTime is out of range" << std::endl;
683 std::cout << minTaktTimeMs << " < tookTime < " << maxTaktTimeMs;
684 std::cout << std::endl;
685 return EVENT_REG_FAIL;
686 }
687 std::this_thread::sleep_for(std::chrono::milliseconds(tookTime));
688 break;
689 }
690 default: {
691 std::cout << "invalid command to virtual mouse" << std::endl;
692 ShowUsage();
693 return EVENT_REG_FAIL;
694 }
695 }
696 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEPTIME));
697 }
698 break;
699 }
700 case 'K': {
701 std::vector<int32_t> downKey;
702 int32_t keyCode = 0;
703 int32_t isCombinationKey = 0;
704 int64_t time = GetSysClockTime();
705 while ((c = getopt_long(argc, argv, "d:u:l:r:i:", keyboardSensorOptions, &optionIndex)) != -1) {
706 switch (c) {
707 case 'd': {
708 if (!StrToInt(optarg, keyCode)) {
709 std::cout << "invalid command to down key" << std::endl;
710 }
711 if (optind == isCombinationKey + TWO_MORE_COMMAND) {
712 downKey.push_back(keyCode);
713 isCombinationKey = optind;
714 auto KeyEvent = KeyEvent::Create();
715 CHKPR(KeyEvent, ERROR_NULL_POINTER);
716 if (downKey.size() > MAX_PRESSED_COUNT) {
717 std::cout << "pressed button count should less than 30" << std::endl;
718 return EVENT_REG_FAIL;
719 }
720 KeyEvent::KeyItem item[downKey.size()];
721 for (size_t i = 0; i < downKey.size(); i++) {
722 KeyEvent->SetKeyCode(keyCode);
723 KeyEvent->SetActionTime(time);
724 KeyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN);
725 item[i].SetKeyCode(downKey[i]);
726 item[i].SetDownTime(time);
727 item[i].SetPressed(true);
728 KeyEvent->AddKeyItem(item[i]);
729 }
730 InputManager::GetInstance()->SimulateInputEvent(KeyEvent);
731 break;
732 }
733 downKey.push_back(keyCode);
734 auto KeyEvent = KeyEvent::Create();
735 CHKPR(KeyEvent, ERROR_NULL_POINTER);
736 KeyEvent->SetKeyCode(keyCode);
737 KeyEvent->SetActionTime(time);
738 KeyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN);
739 KeyEvent::KeyItem item1;
740 item1.SetPressed(true);
741 item1.SetKeyCode(keyCode);
742 item1.SetDownTime(time);
743 KeyEvent->AddKeyItem(item1);
744 InputManager::GetInstance()->SimulateInputEvent(KeyEvent);
745 isCombinationKey = optind;
746 break;
747 }
748 case 'u': {
749 if (!StrToInt(optarg, keyCode)) {
750 std::cout << "invalid button press command" << std::endl;
751 return EVENT_REG_FAIL;
752 }
753 std::vector<int32_t>::iterator iter = std::find(downKey.begin(), downKey.end(), keyCode);
754 if (iter != downKey.end()) {
755 std::cout << "you raised the key " << keyCode << std::endl;
756 auto KeyEvent = KeyEvent::Create();
757 CHKPR(KeyEvent, ERROR_NULL_POINTER);
758 KeyEvent->SetKeyCode(keyCode);
759 KeyEvent->SetActionTime(time);
760 KeyEvent->SetKeyAction(KeyEvent::KEY_ACTION_UP);
761 KeyEvent::KeyItem item1;
762 item1.SetPressed(false);
763 item1.SetKeyCode(keyCode);
764 item1.SetDownTime(time);
765 KeyEvent->AddKeyItem(item1);
766 InputManager::GetInstance()->SimulateInputEvent(KeyEvent);
767 iter = downKey.erase(iter);
768 break;
769 } else {
770 std::cout << "please press the " << keyCode << " key first "<< std::endl;
771 return EVENT_REG_FAIL;
772 }
773 }
774 case 'l': {
775 if (argc < 4) {
776 std::cout << "argc:" << argc << std::endl;
777 std::cout << "wrong number of parameters" << std::endl;
778 return RET_ERR;
779 }
780 if (argc >= 4) {
781 if (!StrToInt(optarg, keyCode)) {
782 std::cout << "invalid key code value" << std::endl;
783 return RET_ERR;
784 }
785 }
786 int32_t pressTimeMs = 3000;
787 if (argc >= 5) {
788 if (!StrToInt(argv[optind], pressTimeMs)) {
789 std::cout << "invalid key code value or press time" << std::endl;
790 return RET_ERR;
791 }
792 }
793 static constexpr int32_t minKeyCode = 0;
794 static constexpr int32_t maxKeyCode = 5000;
795 if ((keyCode < minKeyCode) || (keyCode > maxKeyCode)) {
796 std::cout << "key code is out of range:" << minKeyCode << " <= "
797 << keyCode << " <= " << maxKeyCode << std::endl;
798 return RET_ERR;
799 }
800 static constexpr int32_t minPressTimeMs = 3000;
801 static constexpr int32_t maxPressTimeMs = 15000;
802 if ((pressTimeMs < minPressTimeMs) || (pressTimeMs > maxPressTimeMs)) {
803 std::cout << "press time is out of range:" << minPressTimeMs << " ms" << " <= "
804 << pressTimeMs << " <= " << maxPressTimeMs << " ms" << std::endl;
805 return RET_ERR;
806 }
807 std::cout << " key code: " << keyCode << std::endl
808 << "long press time: " << pressTimeMs << " ms" << std::endl;
809 auto keyEvent = KeyEvent::Create();
810 if (keyEvent == nullptr) {
811 std::cout << "failed to create input event object" << std::endl;
812 return RET_ERR;
813 }
814 keyEvent->SetKeyCode(keyCode);
815 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN);
816 KeyEvent::KeyItem item;
817 item.SetKeyCode(keyCode);
818 item.SetPressed(true);
819 auto keyEventTemp = KeyEvent::Clone(keyEvent);
820 if (keyEventTemp == nullptr) {
821 std::cout << "failed to clone key event object" << std::endl;
822 return RET_ERR;
823 }
824 keyEventTemp->AddKeyItem(item);
825 InputManager::GetInstance()->SimulateInputEvent(keyEventTemp);
826 std::this_thread::sleep_for(std::chrono::milliseconds(pressTimeMs));
827
828 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_UP);
829 item.SetPressed(false);
830 keyEvent->AddKeyItem(item);
831 InputManager::GetInstance()->SimulateInputEvent(keyEvent);
832 break;
833 }
834 case 'r': {
835 constexpr int32_t ARGC_MIN = 4;
836 if (argc < ARGC_MIN) {
837 std::cout << "argc:" << argc << std::endl;
838 std::cout << "wrong number of parameters" << std::endl;
839 return RET_ERR;
840 }
841 if (argc >= ARGC_MIN) {
842 if (!StrToInt(optarg, keyCode)) {
843 std::cout << "invalid key code value" << std::endl;
844 return RET_ERR;
845 }
846 }
847 int32_t pressTimeMs = 3000;
848 constexpr int32_t ARGC_MAX = 5;
849 if (argc >= ARGC_MAX) {
850 if (!StrToInt(argv[optind], pressTimeMs)) {
851 std::cout << "invalid key code value or press time" << std::endl;
852 return RET_ERR;
853 }
854 }
855 static constexpr int32_t minKeyCode = 0;
856 static constexpr int32_t maxKeyCode = 5000;
857 if ((keyCode < minKeyCode) || (keyCode > maxKeyCode)) {
858 std::cout << "key code is out of range:" << minKeyCode << " <= "
859 << keyCode << " <= " << maxKeyCode << std::endl;
860 return RET_ERR;
861 }
862 static constexpr int32_t minPressTimeMs = 3000;
863 static constexpr int32_t maxPressTimeMs = 15000;
864 if ((pressTimeMs < minPressTimeMs) || (pressTimeMs > maxPressTimeMs)) {
865 std::cout << "press time is out of range:" << minPressTimeMs << " ms" << " <= "
866 << pressTimeMs << " <= " << maxPressTimeMs << " ms" << std::endl;
867 return RET_ERR;
868 }
869 std::cout << " key code: " << keyCode << std::endl
870 << "long press time: " << pressTimeMs << " ms" << std::endl;
871 auto keyEvent = KeyEvent::Create();
872 if (keyEvent == nullptr) {
873 std::cout << "failed to create input event object" << std::endl;
874 return RET_ERR;
875 }
876 keyEvent->SetKeyCode(keyCode);
877 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN);
878 KeyEvent::KeyItem item;
879 item.SetKeyCode(keyCode);
880 int64_t time = GetSysClockTime();
881 item.SetPressed(true);
882 auto keyEventTemp = KeyEvent::Clone(keyEvent);
883 if (keyEventTemp == nullptr) {
884 std::cout << "failed to clone key event object" << std::endl;
885 return RET_ERR;
886 }
887 keyEventTemp->SetActionTime(time);
888 keyEventTemp->AddKeyItem(item);
889 keyEventTemp->SetRepeat(true);
890 std::string isRepeat = keyEventTemp->IsRepeat() ? "true" : "false";
891 if (!EventLogHelper::IsBetaVersion()) {
892 MMI_HILOGI("KeyAction:%{public}s, IsRepeat:%{public}s",
893 KeyEvent::ActionToString(keyEventTemp->GetKeyAction()), isRepeat.c_str());
894 } else {
895 MMI_HILOGI("KeyAction:%{public}s, IsRepeat:%{public}s",
896 KeyEvent::ActionToString(keyEventTemp->GetKeyAction()), isRepeat.c_str());
897 }
898 InputManager::GetInstance()->SimulateInputEvent(keyEventTemp);
899 std::this_thread::sleep_for(std::chrono::milliseconds(pressTimeMs));
900
901 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_UP);
902 item.SetPressed(false);
903 keyEvent->AddKeyItem(item);
904 time = GetSysClockTime();
905 keyEvent->SetActionTime(time);
906 keyEvent->SetRepeat(true);
907 isRepeat = keyEvent->IsRepeat() ? "true" : "false";
908 if (!OHOS::MMI::EventLogHelper::IsBetaVersion()) {
909 MMI_HILOGI("KeyAction:%{public}s, IsRepeat:%{public}s",
910 KeyEvent::ActionToString(keyEvent->GetKeyAction()), isRepeat.c_str());
911 } else {
912 MMI_HILOGI("KeyAction:%{public}s, IsRepeat:%{public}s",
913 KeyEvent::ActionToString(keyEvent->GetKeyAction()), isRepeat.c_str());
914 }
915 InputManager::GetInstance()->SimulateInputEvent(keyEvent);
916 break;
917 }
918 case 'i': {
919 int32_t taktTime = 0;
920 if (!StrToInt(optarg, taktTime)) {
921 std::cout << "invalid command to interval time" << std::endl;
922 return EVENT_REG_FAIL;
923 }
924 const int64_t minTaktTimeMs = 1;
925 const int64_t maxTaktTimeMs = 15000;
926 if ((minTaktTimeMs > taktTime) || (maxTaktTimeMs < taktTime)) {
927 std::cout << "taktTime is error" << std::endl;
928 std::cout << minTaktTimeMs << " < taktTime < " << maxTaktTimeMs;
929 std::cout << std::endl;
930 return EVENT_REG_FAIL;
931 }
932 std::this_thread::sleep_for(std::chrono::milliseconds(taktTime));
933 break;
934 }
935 default: {
936 std::cout << "invalid command to keyboard key" << std::endl;
937 ShowUsage();
938 return EVENT_REG_FAIL;
939 }
940 }
941 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEPTIME));
942 }
943 for (size_t i = 0; i < downKey.size(); i++) {
944 std::cout << "you have a key " << downKey[i] << " not release" << std::endl;
945 }
946 break;
947 }
948 case 'S':
949 case 'T': {
950 int32_t px1 = 0;
951 int32_t py1 = 0;
952 int32_t px2 = 0;
953 int32_t py2 = 0;
954 int32_t totalTimeMs = 0;
955 int32_t moveArgcSeven = 7;
956 int32_t firstOpt = c;
957 while ((c = getopt_long(argc, argv, "m:d:u:c:i:g:k", touchSensorOptions, &optionIndex)) != -1) {
958 switch (c) {
959 case 'm': {
960 if (argc < moveArgcSeven || argc > MAX_ARGC) {
961 std::cout << "wrong number of parameters:" << argc << std::endl;
962 return EVENT_REG_FAIL;
963 }
964 struct FingerInfo {
965 int32_t startX = 0;
966 int32_t startY = 0;
967 int32_t endX = 0;
968 int32_t endY = 0;
969 };
970 int32_t startX = 0;
971 int32_t startY = 0;
972 int32_t endX = 0;
973 int32_t endY = 0;
974 int32_t totalTimeMs = 0;
975 int32_t keepTimeMs = 0;
976 int32_t fingerCount = 0;
977 std::vector<FingerInfo> fingerList;
978 int32_t startPos = optind - MOVE_POS_ONE;
979 while (true) {
980 int32_t residueArgc = argc - startPos;
981 if (residueArgc == 0) {
982 totalTimeMs = TOTAL_TIME_MS;
983 optind = startPos;
984 break;
985 } else if (residueArgc == ONE_ARGC) {
986 if (!StrToInt(argv[startPos], totalTimeMs)) {
987 std::cout << "invalid total times" << std::endl;
988 return EVENT_REG_FAIL;
989 }
990 optind = startPos + MOVE_POS_ONE;
991 break;
992 } else if (residueArgc == TWO_ARGC) {
993 totalTimeMs = TOTAL_TIME_MS;
994 if ((strlen(argv[startPos]) != NUM_KEEP_ARGC) ||
995 (argv[startPos][0] != '-') ||
996 (argv[startPos][1] != 'k') ||
997 (!StrToInt(argv[startPos + MOVE_POS_ONE], keepTimeMs))) {
998 std::cout << "invalid keep times" << std::endl;
999 return EVENT_REG_FAIL;
1000 }
1001 optind = startPos + MOVE_POS_TWO;
1002 break;
1003 } else if (residueArgc == THREE_ARGC) {
1004 if (strlen(argv[startPos]) == NUM_KEEP_ARGC) {
1005 if ((argv[startPos][0] != '-') ||
1006 (argv[startPos][1] != 'k') ||
1007 (!StrToInt(argv[startPos + MOVE_POS_ONE], keepTimeMs))) {
1008 std::cout << "invalid keep times" << std::endl;
1009 return EVENT_REG_FAIL;
1010 }
1011 if (!StrToInt(argv[startPos + MOVE_POS_TWO], totalTimeMs)) {
1012 std::cout << "invalid total times" << std::endl;
1013 return EVENT_REG_FAIL;
1014 }
1015 } else {
1016 if (!StrToInt(argv[startPos], totalTimeMs)) {
1017 std::cout << "invalid total times" << std::endl;
1018 return EVENT_REG_FAIL;
1019 }
1020 if ((argv[startPos + MOVE_POS_ONE][0] != '-') ||
1021 (argv[startPos + MOVE_POS_ONE][1] != 'k') ||
1022 (!StrToInt(argv[startPos + MOVE_POS_TWO], keepTimeMs))) {
1023 std::cout << "invalid keep times" << std::endl;
1024 return EVENT_REG_FAIL;
1025 }
1026 }
1027 optind = startPos + MOVE_POS_THREE;
1028 break;
1029 } else if (residueArgc >= FOUR_ARGC) {
1030 if ((!StrToInt(argv[startPos], startX)) ||
1031 (!StrToInt(argv[startPos + MOVE_POS_ONE], startY)) ||
1032 (!StrToInt(argv[startPos + MOVE_POS_TWO], endX)) ||
1033 (!StrToInt(argv[startPos + MOVE_POS_THREE], endY))) {
1034 std::cout << "invalid coordinate value" << std::endl;
1035 return EVENT_REG_FAIL;
1036 }
1037 if ((startX < 0) || (startX < 0) || (endX < 0) || (endY < 0)) {
1038 std::cout << "Coordinate value must be greater or equal than 0" << std::endl;
1039 return RET_ERR;
1040 }
1041 FingerInfo fingerInfoTemp {
1042 .startX = startX,
1043 .startY = startY,
1044 .endX = endX,
1045 .endY = endY
1046 };
1047 fingerList.push_back(fingerInfoTemp);
1048 fingerCount += 1;
1049 startPos += FINGER_LOCATION_NUMS;
1050 optind += THREE_MORE_COMMAND;
1051 } else {
1052 std::cout << "invalid total times" << std::endl;
1053 return EVENT_REG_FAIL;
1054 }
1055 }
1056 for (const auto &finger : fingerList) {
1057 std::cout << "startX:" << finger.startX << ", startY:" << finger.startY <<
1058 ", endX:" << finger.endX << ", endY:" << finger.endY << std::endl;
1059 }
1060 if (keepTimeMs > MAX_KEEP_TIME || keepTimeMs < 0) {
1061 std::cout << "invalid keep times" << std::endl;
1062 return EVENT_REG_FAIL;
1063 }
1064 if (totalTimeMs < 0) {
1065 std::cout << "invalid total times" << std::endl;
1066 return EVENT_REG_FAIL;
1067 }
1068 std::cout << "fingerCount:" << fingerCount <<std::endl;
1069 std::cout << "keepTimeMs:" << keepTimeMs <<std::endl;
1070 std::cout << "totalTimeMs:" << totalTimeMs <<std::endl;
1071
1072 const int64_t minTotalTimeMs = 1;
1073 const int64_t maxTotalTimeMs = 15000;
1074 if ((totalTimeMs < minTotalTimeMs) || (totalTimeMs > maxTotalTimeMs)) {
1075 std::cout << "total time is out of range:" << std::endl;
1076 std::cout << minTotalTimeMs << " <= " << "total times" << " <= " << maxTotalTimeMs;
1077 std::cout << std::endl;
1078 return EVENT_REG_FAIL;
1079 }
1080
1081 auto pointerEvent = PointerEvent::Create();
1082 CHKPR(pointerEvent, ERROR_NULL_POINTER);
1083 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
1084 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
1085 for (int32_t i = 0; i < fingerCount; i++) {
1086 PointerEvent::PointerItem item;
1087 item.SetDisplayX(fingerList[i].startX);
1088 item.SetDisplayY(fingerList[i].startY);
1089 item.SetRawDisplayX(fingerList[i].startX);
1090 item.SetRawDisplayY(fingerList[i].startY);
1091 item.SetPointerId(DEFAULT_POINTER_ID_FIRST + i);
1092 pointerEvent->AddPointerItem(item);
1093 pointerEvent->SetPointerId(DEFAULT_POINTER_ID_FIRST + i);
1094 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
1095 }
1096
1097 int64_t startTimeUs = pointerEvent->GetActionStartTime();
1098 int64_t startTimeMs = startTimeUs / TIME_TRANSITION;
1099 int64_t endTimeMs = 0;
1100 if (!AddInt64(startTimeMs, totalTimeMs, endTimeMs)) {
1101 std::cout << "system time error." << std::endl;
1102 return EVENT_REG_FAIL;
1103 }
1104 int64_t currentTimeMs = startTimeMs;
1105 int64_t nowSysTimeUs = 0;
1106 int64_t nowSysTimeMs = 0;
1107 int64_t sleepTimeMs = 0;
1108
1109 std::vector<int32_t> pointerIds = pointerEvent->GetPointerIds();
1110 if (pointerIds.size() != static_cast<size_t>(fingerCount)) {
1111 std::cout << "pointerIds size is error" << std::endl;
1112 return EVENT_REG_FAIL;
1113 }
1114
1115 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
1116 while (currentTimeMs < endTimeMs) {
1117 for (size_t i = 0; i < pointerIds.size(); i++) {
1118 int32_t pointerId = pointerIds[i];
1119 PointerEvent::PointerItem item;
1120 if (!pointerEvent->GetPointerItem(pointerId, item)) {
1121 std::cout << "Invalid pointer:" << pointerId << std::endl;
1122 return EVENT_REG_FAIL;
1123 }
1124 item.SetDisplayX(NextPos(startTimeMs, currentTimeMs, totalTimeMs,
1125 fingerList[i].startX, fingerList[i].endX));
1126 item.SetDisplayY(NextPos(startTimeMs, currentTimeMs, totalTimeMs,
1127 fingerList[i].startY, fingerList[i].endY));
1128 item.SetRawDisplayX(NextPos(startTimeMs, currentTimeMs, totalTimeMs,
1129 fingerList[i].startX, fingerList[i].endX));
1130 item.SetRawDisplayY(NextPos(startTimeMs, currentTimeMs, totalTimeMs,
1131 fingerList[i].startY, fingerList[i].endY));
1132 pointerEvent->UpdatePointerItem(pointerId, item);
1133 pointerEvent->SetPointerId(pointerId);
1134 pointerEvent->SetActionTime(currentTimeMs * TIME_TRANSITION);
1135 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
1136 }
1137 nowSysTimeUs = GetSysClockTime();
1138 nowSysTimeMs = nowSysTimeUs / TIME_TRANSITION;
1139 sleepTimeMs = (currentTimeMs + BLOCK_TIME_MS) - nowSysTimeMs;
1140 std::this_thread::sleep_for(std::chrono::milliseconds(sleepTimeMs));
1141 currentTimeMs += BLOCK_TIME_MS;
1142 }
1143
1144 for (size_t i = 0; i < pointerIds.size(); i++) {
1145 int32_t pointerId = pointerIds[i];
1146 PointerEvent::PointerItem item;
1147 if (!pointerEvent->GetPointerItem(pointerId, item)) {
1148 std::cout << "Invalid pointer:" << pointerId << std::endl;
1149 return EVENT_REG_FAIL;
1150 }
1151 item.SetDisplayX(fingerList[i].endX);
1152 item.SetDisplayY(fingerList[i].endY);
1153 item.SetRawDisplayX(fingerList[i].endX);
1154 item.SetRawDisplayY(fingerList[i].endY);
1155 pointerEvent->UpdatePointerItem(pointerId, item);
1156 pointerEvent->SetPointerId(pointerId);
1157 pointerEvent->SetActionTime(currentTimeMs * TIME_TRANSITION);
1158 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
1159 }
1160 std::this_thread::sleep_for(std::chrono::milliseconds(BLOCK_TIME_MS));
1161
1162 if (keepTimeMs > 0) {
1163 currentTimeMs = GetSysClockTime() / TIME_TRANSITION;
1164 int64_t keepEndTimeMs = 0;
1165 if (!AddInt64(currentTimeMs, keepTimeMs, keepEndTimeMs)) {
1166 std::cout << "system time error." << std::endl;
1167 return EVENT_REG_FAIL;
1168 }
1169 while (currentTimeMs < keepEndTimeMs) {
1170 for (size_t i = 0; i < pointerIds.size(); i++) {
1171 int32_t pointerId = pointerIds[i];
1172 PointerEvent::PointerItem item;
1173 if (!pointerEvent->GetPointerItem(pointerId, item)) {
1174 std::cout << "Invalid pointer:" << pointerId << std::endl;
1175 return EVENT_REG_FAIL;
1176 }
1177 item.SetDisplayX(fingerList[i].endX);
1178 item.SetDisplayY(fingerList[i].endY);
1179 item.SetRawDisplayX(fingerList[i].endX);
1180 item.SetRawDisplayY(fingerList[i].endY);
1181 pointerEvent->UpdatePointerItem(pointerId, item);
1182 pointerEvent->SetPointerId(pointerId);
1183 pointerEvent->SetActionTime(currentTimeMs * TIME_TRANSITION);
1184 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
1185 }
1186 nowSysTimeUs = GetSysClockTime();
1187 nowSysTimeMs = nowSysTimeUs / TIME_TRANSITION;
1188 sleepTimeMs = (currentTimeMs + BLOCK_TIME_MS) - nowSysTimeMs;
1189 std::this_thread::sleep_for(std::chrono::milliseconds(sleepTimeMs));
1190 currentTimeMs += BLOCK_TIME_MS;
1191 }
1192 }
1193
1194 pointerEvent->SetActionTime((endTimeMs + BLOCK_TIME_MS) * TIME_TRANSITION);
1195 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
1196 for (size_t i = 0; i < pointerIds.size(); i++) {
1197 int32_t pointerId = pointerIds[i];
1198 PointerEvent::PointerItem item;
1199 if (!pointerEvent->GetPointerItem(pointerId, item)) {
1200 std::cout << "Invalid pointer:" << pointerId << std::endl;
1201 return EVENT_REG_FAIL;
1202 }
1203 pointerEvent->UpdatePointerItem(pointerId, item);
1204 pointerEvent->SetPointerId(pointerId);
1205 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
1206 pointerEvent->RemovePointerItem(pointerId);
1207 }
1208 break;
1209 }
1210 case 'd': {
1211 if (optind >= argc) {
1212 std::cout << "too few arguments to function" << std::endl;
1213 return EVENT_REG_FAIL;
1214 }
1215 if (!StrToInt(optarg, px1) || !StrToInt(argv[optind], py1)) {
1216 std::cout << "invalid coordinate value" << std::endl;
1217 return EVENT_REG_FAIL;
1218 }
1219 if ((px1 < 0) || (py1 < 0)) {
1220 std::cout << "Coordinate value must be greater or equal than 0" << std::endl;
1221 return RET_ERR;
1222 }
1223 std::cout << "touch down " << px1 << " " << py1 << std::endl;
1224 auto pointerEvent = PointerEvent::Create();
1225 CHKPR(pointerEvent, ERROR_NULL_POINTER);
1226 PointerEvent::PointerItem item;
1227 item.SetDisplayY(py1);
1228 item.SetRawDisplayY(py1);
1229 item.SetPointerId(DEFAULT_POINTER_ID_FIRST);
1230 item.SetDisplayX(px1);
1231 item.SetRawDisplayX(px1);
1232 pointerEvent->SetPointerId(DEFAULT_POINTER_ID_FIRST);
1233 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
1234 pointerEvent->AddPointerItem(item);
1235 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
1236 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
1237 optind++;
1238 break;
1239 }
1240 case 'u': {
1241 if (optind >= argc) {
1242 std::cout << "too few arguments to function" << std::endl;
1243 return EVENT_REG_FAIL;
1244 }
1245 if (!StrToInt(optarg, px1) || !StrToInt(argv[optind], py1)) {
1246 std::cout << "invalid coordinate value" << std::endl;
1247 return EVENT_REG_FAIL;
1248 }
1249 if ((px1 < 0) || (py1 < 0)) {
1250 std::cout << "Coordinate value must be greater or equal than 0" << std::endl;
1251 return RET_ERR;
1252 }
1253 std::cout << "touch up " << px1 << " " << py1 << std::endl;
1254 auto pointerEvent = PointerEvent::Create();
1255 CHKPR(pointerEvent, ERROR_NULL_POINTER);
1256 PointerEvent::PointerItem item;
1257 item.SetDisplayY(py1);
1258 item.SetRawDisplayY(py1);
1259 item.SetPointerId(DEFAULT_POINTER_ID_FIRST);
1260 item.SetDisplayX(px1);
1261 item.SetRawDisplayX(px1);
1262 pointerEvent->SetPointerId(DEFAULT_POINTER_ID_FIRST);
1263 pointerEvent->AddPointerItem(item);
1264 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
1265 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
1266 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
1267 optind++;
1268 break;
1269 }
1270 case 'c': {
1271 int32_t intervalTimeMs = 0;
1272 if (argc == KEY_PARAM_SIZE) {
1273 if (!StrToInt(optarg, px1) ||
1274 !StrToInt(argv[optind], py1)) {
1275 std::cout << "input coordinate error" << std::endl;
1276 return RET_ERR;
1277 }
1278 intervalTimeMs = INTERVAL_TIME_MS;
1279 } else if (argc == KEY_TIME_PARAM_SIZE) {
1280 if (!StrToInt(optarg, px1) ||
1281 !StrToInt(argv[optind], py1) ||
1282 !StrToInt(argv[optind + 1], intervalTimeMs)) {
1283 std::cout << "input coordinate or time error" << std::endl;
1284 return RET_ERR;
1285 }
1286 const int64_t minIntervalTimeMs = 1;
1287 const int64_t maxIntervalTimeMs = 450;
1288 if ((minIntervalTimeMs > intervalTimeMs) || (maxIntervalTimeMs < intervalTimeMs)) {
1289 std::cout << "interval time is out of range: " << minIntervalTimeMs << "ms";
1290 std::cout << " < interval time < " << maxIntervalTimeMs << "ms" << std::endl;
1291 return RET_ERR;
1292 }
1293 } else {
1294 std::cout << "parameter error, unable to run" << std::endl;
1295 return RET_ERR;
1296 }
1297 if ((px1 < 0) || (py1 < 0)) {
1298 std::cout << "Coordinate value must be greater or equal than 0" << std::endl;
1299 return RET_ERR;
1300 }
1301 std::cout << " click coordinate: ("<< px1 << ", " << py1 << ")" << std::endl;
1302 std::cout << "click interval time: " << intervalTimeMs << "ms" << std::endl;
1303 auto pointerEvent = PointerEvent::Create();
1304 CHKPR(pointerEvent, ERROR_NULL_POINTER);
1305 PointerEvent::PointerItem item;
1306 item.SetPointerId(DEFAULT_POINTER_ID_FIRST);
1307 item.SetDisplayX(px1);
1308 item.SetDisplayY(py1);
1309 item.SetRawDisplayX(px1);
1310 item.SetRawDisplayY(py1);
1311 item.SetPressed(true);
1312 pointerEvent->SetPointerId(DEFAULT_POINTER_ID_FIRST);
1313 pointerEvent->AddPointerItem(item);
1314 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
1315 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
1316 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
1317 std::this_thread::sleep_for(std::chrono::milliseconds(intervalTimeMs));
1318
1319 item.SetPressed(false);
1320 item.SetDisplayY(py1);
1321 item.SetDisplayX(px1);
1322 item.SetRawDisplayY(py1);
1323 item.SetRawDisplayX(px1);
1324 pointerEvent->UpdatePointerItem(DEFAULT_POINTER_ID_FIRST, item);
1325 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
1326 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
1327 break;
1328 }
1329 case 'i': {
1330 int32_t takeTime = 0;
1331 if (!StrToInt(optarg, takeTime)) {
1332 std::cout << "invalid command to interval time" << std::endl;
1333 return EVENT_REG_FAIL;
1334 }
1335 const int64_t minTakeTimeMs = 1;
1336 const int64_t maxTakeTimeMs = 15000;
1337 if ((minTakeTimeMs > takeTime) || (maxTakeTimeMs < takeTime)) {
1338 std::cout << "takeTime is out of range. ";
1339 std::cout << minTakeTimeMs << " < takeTime < " << maxTakeTimeMs;
1340 std::cout << std::endl;
1341 return EVENT_REG_FAIL;
1342 }
1343 std::this_thread::sleep_for(std::chrono::milliseconds(takeTime));
1344 break;
1345 }
1346 case 'g': {
1347 const int32_t dragArgcSeven = 7;
1348 const int32_t dragArgcCommandNine = 9;
1349 if ((argc != dragArgcSeven) && (argc != dragArgcCommandNine)) {
1350 std::cout << "argc:" << argc << std::endl;
1351 std::cout << "wrong number of parameters" << std::endl;
1352 return RET_ERR;
1353 }
1354 totalTimeMs = TOTAL_TIME_MS;
1355 int32_t pressTimems = 500;
1356 if (argc == moveArgcSeven) {
1357 if ((!StrToInt(optarg, px1)) ||
1358 (!StrToInt(argv[optind], py1)) ||
1359 (!StrToInt(argv[optind + 1], px2)) ||
1360 (!StrToInt(argv[optind + 2], py2))) {
1361 std::cout << "invalid coordinate value" << std::endl;
1362 return RET_ERR;
1363 }
1364 } else {
1365 if ((!StrToInt(optarg, px1)) ||
1366 (!StrToInt(argv[optind], py1)) ||
1367 (!StrToInt(argv[optind + 1], px2)) ||
1368 (!StrToInt(argv[optind + 2], py2)) ||
1369 (!StrToInt(argv[optind + 3], pressTimems)) ||
1370 (!StrToInt(argv[optind + 4], totalTimeMs))) {
1371 std::cout << "invalid input coordinate or time" << std::endl;
1372 return RET_ERR;
1373 }
1374 }
1375 if ((px1 < 0) || (py1 < 0) || (px2 < 0) || (py2 < 0)) {
1376 std::cout << "Coordinate value must be greater or equal than 0" << std::endl;
1377 return RET_ERR;
1378 }
1379 const int32_t minTotalTimeMs = 1000;
1380 const int32_t maxTotalTimeMs = 15000;
1381 if ((minTotalTimeMs > totalTimeMs) || (maxTotalTimeMs < totalTimeMs)) {
1382 std::cout << "total time input is error" << std::endl;
1383 return RET_ERR;
1384 }
1385 const int32_t minPressTimeMs = 500;
1386 const int32_t maxPressTimeMs = 14500;
1387 if ((minPressTimeMs > pressTimems) || (maxPressTimeMs < pressTimems)) {
1388 std::cout << "press time is out of range" << std::endl;
1389 return RET_ERR;
1390 }
1391 const int32_t minMoveTimeMs = 500;
1392 if ((totalTimeMs - pressTimems) < minMoveTimeMs) {
1393 std::cout << "move time is out of range" << std::endl;
1394 return RET_ERR;
1395 }
1396 auto pointerEvent = PointerEvent::Create();
1397 CHKPR(pointerEvent, ERROR_NULL_POINTER);
1398 PointerEvent::PointerItem item;
1399 item.SetPointerId(DEFAULT_POINTER_ID_FIRST);
1400 item.SetDisplayY(py1);
1401 item.SetDisplayX(px1);
1402 item.SetRawDisplayY(py1);
1403 item.SetRawDisplayX(px1);
1404 pointerEvent->AddPointerItem(item);
1405 pointerEvent->SetPointerId(DEFAULT_POINTER_ID_FIRST);
1406 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
1407 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
1408 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
1409 const int32_t conversionRate = 1000;
1410 int64_t startTimeMs = GetSysClockTime() / conversionRate;
1411 int64_t endTimeMs = 0;
1412 if (!AddInt64(startTimeMs, totalTimeMs, endTimeMs)) {
1413 std::cout << "end time count error" << std::endl;
1414 return RET_ERR;
1415 }
1416 int64_t downTimeMs = 0;
1417 if (!AddInt64(startTimeMs, pressTimems, downTimeMs)) {
1418 std::cout << "down time count error" << std::endl;
1419 return RET_ERR;
1420 }
1421 int64_t currentTimeMs = startTimeMs;
1422 const int32_t moveTimeMs = totalTimeMs - pressTimems;
1423 while ((currentTimeMs < endTimeMs)) {
1424 if (currentTimeMs > downTimeMs) {
1425 item.SetDisplayX(NextPos(downTimeMs, currentTimeMs, moveTimeMs, px1, px2));
1426 item.SetDisplayY(NextPos(downTimeMs, currentTimeMs, moveTimeMs, py1, py2));
1427 item.SetRawDisplayX(NextPos(downTimeMs, currentTimeMs, moveTimeMs, px1, px2));
1428 item.SetRawDisplayY(NextPos(downTimeMs, currentTimeMs, moveTimeMs, py1, py2));
1429 pointerEvent->UpdatePointerItem(DEFAULT_POINTER_ID_FIRST, item);
1430 pointerEvent->SetActionTime(currentTimeMs * TIME_TRANSITION);
1431 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
1432 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
1433 }
1434 std::this_thread::sleep_for(std::chrono::milliseconds(BLOCK_TIME_MS));
1435 currentTimeMs = GetSysClockTime() / conversionRate;
1436 }
1437 item.SetDisplayX(px2);
1438 item.SetDisplayY(py2);
1439 item.SetRawDisplayX(px2);
1440 item.SetRawDisplayY(py2);
1441 pointerEvent->UpdatePointerItem(DEFAULT_POINTER_ID_FIRST, item);
1442 pointerEvent->SetActionTime(endTimeMs * TIME_TRANSITION);
1443 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
1444 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
1445 break;
1446 }
1447 case 'k': {
1448 if (firstOpt == 'S') {
1449 std::cout << "invalid argument k" << std::endl;
1450 return EVENT_REG_FAIL;
1451 }
1452 KnuckleGestureInputProcess(argc, argv, c, optionIndex);
1453 break;
1454 }
1455 default: {
1456 std::cout << "invalid command" << std::endl;
1457 ShowUsage();
1458 return EVENT_REG_FAIL;
1459 }
1460 }
1461 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEPTIME));
1462 }
1463 break;
1464 }
1465 case 'J': {
1466 JoystickInfo joyInfo;
1467 std::vector<std::pair<int32_t, JoystickInfo>> state;
1468 while ((c = getopt_long(argc, argv, "m:d:u:c:i:", joystickSensorOptions, &optionIndex)) != -1) {
1469 switch (c) {
1470 case 'm': {
1471 std::string arg(optarg);
1472 std::string::size_type pos = arg.find('=');
1473 if (pos == std::string::npos) {
1474 std::cout << "Parameter format is error" << std::endl;
1475 return EVENT_REG_FAIL;
1476 }
1477 std::string absAction = arg.substr(0, pos);
1478 if (absAction == "x") {
1479 joyInfo.absType = PointerEvent::AxisType::AXIS_TYPE_ABS_X;
1480 } else if (absAction == "y") {
1481 joyInfo.absType = PointerEvent::AxisType::AXIS_TYPE_ABS_Y;
1482 } else if (absAction == "z") {
1483 joyInfo.absType = PointerEvent::AxisType::AXIS_TYPE_ABS_Z;
1484 } else if (absAction == "rz") {
1485 joyInfo.absType = PointerEvent::AxisType::AXIS_TYPE_ABS_RZ;
1486 } else if (absAction == "gas") {
1487 joyInfo.absType = PointerEvent::AxisType::AXIS_TYPE_ABS_GAS;
1488 } else if (absAction == "brake") {
1489 joyInfo.absType = PointerEvent::AxisType::AXIS_TYPE_ABS_BRAKE;
1490 } else if (absAction == "hat0x") {
1491 joyInfo.absType = PointerEvent::AxisType::AXIS_TYPE_ABS_HAT0X;
1492 } else if (absAction == "hat0y") {
1493 joyInfo.absType = PointerEvent::AxisType::AXIS_TYPE_ABS_HAT0Y;
1494 } else if (absAction == "throttle") {
1495 joyInfo.absType = PointerEvent::AxisType::AXIS_TYPE_ABS_THROTTLE;
1496 } else {
1497 std::cout << "Invalid abstype" << std::endl;
1498 return RET_ERR;
1499 }
1500 if (!StrToInt(arg.substr(pos + 1), joyInfo.absValue)) {
1501 std::cout << "Invalid parameter to move absValue" << std::endl;
1502 return EVENT_REG_FAIL;
1503 }
1504 state.push_back(std::pair<int32_t, JoystickInfo>(JOYSTICK_MOVE, joyInfo));
1505 break;
1506 }
1507 case 'd': {
1508 if (!StrToInt(optarg, joyInfo.buttonId)) {
1509 std::cout << "Invalid button press command" << std::endl;
1510 return EVENT_REG_FAIL;
1511 }
1512 if (joyInfo.buttonId > JOYSTICK_BUTTON_ID) {
1513 std::cout << "Pressed button value is greater than the max value" << std::endl;
1514 return EVENT_REG_FAIL;
1515 }
1516 state.push_back(std::pair<int32_t, JoystickInfo>(JOYSTICK_BUTTON_PRESS, joyInfo));
1517 break;
1518 }
1519 case 'u': {
1520 if (!StrToInt(optarg, joyInfo.buttonId)) {
1521 std::cout << "Invalid raise button command" << std::endl;
1522 return EVENT_REG_FAIL;
1523 }
1524 if (joyInfo.buttonId > JOYSTICK_BUTTON_ID) {
1525 std::cout << "Raise button value is greater than the max value" << std::endl;
1526 return EVENT_REG_FAIL;
1527 }
1528 state.push_back(std::pair<int32_t, JoystickInfo>(JOYSTICK_BUTTON_UP, joyInfo));
1529 break;
1530 }
1531 case 'c': {
1532 if (!StrToInt(optarg, joyInfo.buttonId)) {
1533 std::cout << "Invalid click button command" << std::endl;
1534 return EVENT_REG_FAIL;
1535 }
1536 if (joyInfo.buttonId > JOYSTICK_BUTTON_ID) {
1537 std::cout << "Click button value is greater than the max value" << std::endl;
1538 return EVENT_REG_FAIL;
1539 }
1540 state.push_back(std::pair<int32_t, JoystickInfo>(JOYSTICK_CLICK, joyInfo));
1541 break;
1542 }
1543 case 'i': {
1544 if (!StrToInt(optarg, joyInfo.taktTime)) {
1545 std::cout << "Invalid command to interval time" << std::endl;
1546 return EVENT_REG_FAIL;
1547 }
1548 state.push_back(std::pair<int32_t, JoystickInfo>(JOYSTICK_INTERVAL, joyInfo));
1549 break;
1550 }
1551 default: {
1552 std::cout << "Invalid options" << std::endl;
1553 ShowUsage();
1554 return EVENT_REG_FAIL;
1555 }
1556 }
1557 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEPTIME));
1558 }
1559 auto pointerEvent = PointerEvent::Create();
1560 if (pointerEvent != nullptr) {
1561 if (optind < argc) {
1562 std::cout << "non-option argv elements: ";
1563 while (optind < argc) {
1564 std::cout << argv[optind++] << "\t";
1565 }
1566 std::cout << std::endl;
1567 return EVENT_REG_FAIL;
1568 }
1569 if (state.empty()) {
1570 std::cout << "Injection failed" << std::endl;
1571 return EVENT_REG_FAIL;
1572 }
1573 for (const auto &it : state) {
1574 if (it.first == JOYSTICK_BUTTON_PRESS) {
1575 std::cout << "Press down " << it.second.buttonId <<std::endl;
1576 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_BUTTON_DOWN);
1577 pointerEvent->SetButtonId(it.second.buttonId);
1578 pointerEvent->SetButtonPressed(it.second.buttonId);
1579 } else if (it.first == JOYSTICK_BUTTON_UP) {
1580 std::cout << "Lift up button " << it.second.buttonId << std::endl;
1581 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_BUTTON_UP);
1582 pointerEvent->SetButtonPressed(it.second.buttonId);
1583 pointerEvent->SetButtonId(it.second.buttonId);
1584 } else if (it.first == JOYSTICK_MOVE) {
1585 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_AXIS_UPDATE);
1586 pointerEvent->SetAxisValue(it.second.absType, it.second.absValue);
1587 } else if (it.first == JOYSTICK_CLICK) {
1588 std::cout << "Click " << it.second.buttonId << std::endl;
1589 pointerEvent->SetButtonId(it.second.buttonId);
1590 pointerEvent->SetPointerId(0);
1591 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_BUTTON_DOWN);
1592 pointerEvent->SetButtonPressed(it.second.buttonId);
1593 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_JOYSTICK);
1594 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
1595
1596 pointerEvent->SetButtonPressed(it.second.buttonId);
1597 pointerEvent->SetButtonId(it.second.buttonId);
1598 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_BUTTON_UP);
1599 } else if (it.first == JOYSTICK_INTERVAL) {
1600 if ((MIN_TAKTTIME_MS > joyInfo.taktTime) || (MAX_TAKTTIME_MS < joyInfo.taktTime)) {
1601 std::cout << "TaktTime is out of range" << std::endl;
1602 return EVENT_REG_FAIL;
1603 }
1604 std::this_thread::sleep_for(std::chrono::milliseconds(joyInfo.taktTime));
1605 continue;
1606 }
1607 pointerEvent->SetPointerId(0);
1608 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_JOYSTICK);
1609 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
1610 }
1611 }
1612 break;
1613 }
1614 case 'P': {
1615 int32_t ret = ProcessTouchPadGestureInput(argc, argv, optionIndex);
1616 if (ret != ERR_OK) {
1617 return ret;
1618 }
1619 break;
1620 }
1621 case '?': {
1622 ShowUsage();
1623 return ERR_OK;
1624 }
1625 default: {
1626 std::cout << "invalid command" << std::endl;
1627 ShowUsage();
1628 return EVENT_REG_FAIL;
1629 }
1630 }
1631 } else {
1632 std::cout << "too few arguments to function" << std::endl;
1633 ShowUsage();
1634 return EVENT_REG_FAIL;
1635 }
1636 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEPTIME));
1637 return ERR_OK;
1638 }
1639
KnuckleGestureInputProcess(int32_t argc,char * argv[],int32_t c,int32_t optionIndex)1640 int32_t InputManagerCommand::KnuckleGestureInputProcess(int32_t argc, char *argv[], int32_t c, int32_t optionIndex)
1641 {
1642 struct option knuckleGestureSensorOptions[] = {
1643 {"single_finger_double_click", required_argument, nullptr, 's'},
1644 {"double_finger_double_click", required_argument, nullptr, 'd'},
1645 {nullptr, 0, nullptr, 0}
1646 };
1647
1648 while ((c = getopt_long(argc, argv, "s:d:", knuckleGestureSensorOptions, &optionIndex)) != -1) {
1649 switch (c) {
1650 case 's': {
1651 SingleKnuckleGestureProcesser(argc, argv);
1652 break;
1653 }
1654 case 'd': {
1655 DoubleKnuckleGestureProcesser(argc, argv);
1656 break;
1657 }
1658 default: {
1659 std::cout << "invalid command" << std::endl;
1660 ShowUsage();
1661 return EVENT_REG_FAIL;
1662 }
1663 }
1664 }
1665 return ERR_OK;
1666 }
1667
SingleKnuckleGestureProcesser(int32_t argc,char * argv[])1668 int32_t InputManagerCommand::SingleKnuckleGestureProcesser(int32_t argc, char *argv[])
1669 {
1670 int32_t knuckleUinputArgc = 8;
1671 int32_t intervalTimeMs = 0;
1672 int32_t firstDownX = 0;
1673 int32_t firstDownY = 0;
1674 int32_t secondDownX = 0;
1675 int32_t secondDownY = 0;
1676 if (optind < 0 || optind > argc) {
1677 std::cout << "wrong optind pointer index" << std::endl;
1678 return EVENT_REG_FAIL;
1679 }
1680 if (argc == knuckleUinputArgc) {
1681 if ((!StrToInt(optarg, firstDownX)) || !StrToInt(argv[optind], firstDownY) ||
1682 !StrToInt(argv[optind + 1], secondDownX) || !StrToInt(argv[optind + TWO_MORE_COMMAND], secondDownY)) {
1683 std::cout << "invalid coordinate value" << std::endl;
1684 return EVENT_REG_FAIL;
1685 }
1686 intervalTimeMs = DEFAULT_DELAY;
1687 } else if (argc == KNUCKLE_PARAM_SIZE) {
1688 if ((!StrToInt(optarg, firstDownX)) || !StrToInt(argv[optind], firstDownY) ||
1689 !StrToInt(argv[optind + 1], secondDownX) || !StrToInt(argv[optind + TWO_MORE_COMMAND], secondDownY) ||
1690 !StrToInt(argv[optind + THREE_MORE_COMMAND], intervalTimeMs)) {
1691 std::cout << "input coordinate or time error" << std::endl;
1692 return RET_ERR;
1693 }
1694 const int64_t minIntervalTimeMs = 1;
1695 const int64_t maxIntervalTimeMs = 250;
1696 if ((minIntervalTimeMs > intervalTimeMs) || (maxIntervalTimeMs < intervalTimeMs)) {
1697 std::cout << "interval time is out of range: " << minIntervalTimeMs << "ms";
1698 std::cout << " < interval time < " << maxIntervalTimeMs << "ms" << std::endl;
1699 return RET_ERR;
1700 }
1701 } else {
1702 std::cout << "wrong number of parameters:" << argc << std::endl;
1703 return EVENT_REG_FAIL;
1704 }
1705 if (IsCoordinateInvalid(firstDownX, firstDownY, secondDownX, secondDownY)) {
1706 std::cout << "Coordinate value must be greater or equal than 0" << std::endl;
1707 return RET_ERR;
1708 }
1709 std::cout << "single knuckle first down coordinate: ("<< firstDownX << ", " << firstDownY << ")" << std::endl;
1710 std::cout << "single knuckle second down coordinate: ("<< secondDownX << ", " << secondDownY << ")" << std::endl;
1711 std::cout << "single knuckle interval time: " << intervalTimeMs << "ms" << std::endl;
1712 SingleKnuckleClickEvent(firstDownX, firstDownY);
1713 std::this_thread::sleep_for(std::chrono::milliseconds(intervalTimeMs));
1714 SingleKnuckleClickEvent(secondDownX, secondDownY);
1715 return ERR_OK;
1716 }
1717
DoubleKnuckleGestureProcesser(int32_t argc,char * argv[])1718 int32_t InputManagerCommand::DoubleKnuckleGestureProcesser(int32_t argc, char *argv[])
1719 {
1720 int32_t knuckleUinputArgc = 8;
1721 int32_t intervalTimeMs = 0;
1722 int32_t firstDownX = 0;
1723 int32_t firstDownY = 0;
1724 int32_t secondDownX = 0;
1725 int32_t secondDownY = 0;
1726 if (optind < 0 || optind > argc) {
1727 std::cout << "wrong optind pointer index" << std::endl;
1728 return EVENT_REG_FAIL;
1729 }
1730 if (argc == knuckleUinputArgc) {
1731 if (!StrToInt(optarg, firstDownX) || !StrToInt(argv[optind], firstDownY) ||
1732 !StrToInt(argv[optind + 1], secondDownX) || !StrToInt(argv[optind + TWO_MORE_COMMAND], secondDownY)) {
1733 std::cout << "invalid coordinate value" << std::endl;
1734 return EVENT_REG_FAIL;
1735 }
1736 intervalTimeMs = DEFAULT_DELAY;
1737 } else if (argc == KNUCKLE_PARAM_SIZE) {
1738 if ((!StrToInt(optarg, firstDownX)) || !StrToInt(argv[optind], firstDownY) ||
1739 !StrToInt(argv[optind + 1], secondDownX) || !StrToInt(argv[optind + TWO_MORE_COMMAND], secondDownY) ||
1740 !StrToInt(argv[optind + THREE_MORE_COMMAND], intervalTimeMs)) {
1741 std::cout << "input coordinate or time error" << std::endl;
1742 return RET_ERR;
1743 }
1744 const int64_t minIntervalTimeMs = 1;
1745 const int64_t maxIntervalTimeMs = 250;
1746 if ((minIntervalTimeMs > intervalTimeMs) || (maxIntervalTimeMs < intervalTimeMs)) {
1747 std::cout << "interval time is out of range: " << minIntervalTimeMs << "ms";
1748 std::cout << " < interval time < " << maxIntervalTimeMs << "ms" << std::endl;
1749 return RET_ERR;
1750 }
1751 } else {
1752 std::cout << "wrong number of parameters: " << argc << std::endl;
1753 return EVENT_REG_FAIL;
1754 }
1755 if (IsCoordinateInvalid(firstDownX, firstDownY, secondDownX, secondDownY)) {
1756 std::cout << "Coordinate value must be greater or equal than 0" << std::endl;
1757 return RET_ERR;
1758 }
1759 std::cout << "double knukle first click coordinate: ("<< firstDownX << ", " << firstDownY << ")" << std::endl;
1760 std::cout << "double knukle second click coordinate: ("<< secondDownX << ", " << secondDownY << ")" << std::endl;
1761 std::cout << "double knuckle interval time: " << intervalTimeMs << "ms" << std::endl;
1762
1763 DoubleKnuckleClickEvent(firstDownX, firstDownY);
1764 std::this_thread::sleep_for(std::chrono::milliseconds(intervalTimeMs));
1765 DoubleKnuckleClickEvent(secondDownX, secondDownY);
1766 return ERR_OK;
1767 }
1768
IsCoordinateInvalid(int32_t firstDownX,int32_t firstDownY,int32_t secondDownX,int32_t secondDownY)1769 bool InputManagerCommand::IsCoordinateInvalid(int32_t firstDownX, int32_t firstDownY, int32_t secondDownX,
1770 int32_t secondDownY)
1771 {
1772 return firstDownX < 0 || firstDownY < 0 || secondDownX < 0 || secondDownY < 0;
1773 }
1774
SingleKnuckleClickEvent(int32_t downX,int32_t downY)1775 int32_t InputManagerCommand::SingleKnuckleClickEvent(int32_t downX, int32_t downY)
1776 {
1777 auto pointerEvent = PointerEvent::Create();
1778 CHKPR(pointerEvent, ERROR_NULL_POINTER);
1779 PointerEvent::PointerItem item;
1780 item.SetPointerId(0);
1781 item.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE);
1782 item.SetDisplayX(downX);
1783 item.SetDisplayY(downY);
1784 item.SetRawDisplayX(downX);
1785 item.SetRawDisplayY(downY);
1786 item.SetPressed(true);
1787 pointerEvent->SetPointerId(0);
1788 pointerEvent->AddPointerItem(item);
1789 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
1790 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
1791 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
1792
1793 item.SetPressed(false);
1794 item.SetDisplayY(downY);
1795 item.SetDisplayX(downX);
1796 item.SetRawDisplayY(downY);
1797 item.SetRawDisplayX(downX);
1798 item.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE);
1799 pointerEvent->UpdatePointerItem(0, item);
1800 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
1801 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
1802 return ERR_OK;
1803 }
1804
DoubleKnuckleClickEvent(int32_t downX,int32_t downY)1805 int32_t InputManagerCommand::DoubleKnuckleClickEvent(int32_t downX, int32_t downY)
1806 {
1807 auto pointerEvent = PointerEvent::Create();
1808 CHKPR(pointerEvent, ERROR_NULL_POINTER);
1809 PointerEvent::PointerItem item;
1810 PointerEvent::PointerItem item2;
1811 item.SetPointerId(0);
1812 item.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE);
1813 item.SetDisplayX(downX);
1814 item.SetDisplayY(downY);
1815 item.SetRawDisplayX(downX);
1816 item.SetRawDisplayY(downY);
1817 item.SetPressed(true);
1818 pointerEvent->SetPointerId(0);
1819 pointerEvent->AddPointerItem(item);
1820
1821 item2.SetPointerId(1);
1822 item2.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE);
1823 item2.SetDisplayX(downX);
1824 item2.SetDisplayY(downY);
1825 item2.SetRawDisplayX(downX);
1826 item2.SetRawDisplayY(downY);
1827 item2.SetPressed(true);
1828 pointerEvent->SetPointerId(1);
1829 pointerEvent->AddPointerItem(item2);
1830 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
1831 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
1832 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
1833
1834 item.SetPressed(false);
1835 item.SetDisplayY(downY);
1836 item.SetDisplayX(downX);
1837 item.SetRawDisplayY(downY);
1838 item.SetRawDisplayX(downX);
1839 item.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE);
1840 item2.SetPressed(false);
1841 item2.SetDisplayY(downY);
1842 item2.SetDisplayX(downX);
1843 item2.SetRawDisplayY(downY);
1844 item2.SetRawDisplayX(downX);
1845 item2.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE);
1846 pointerEvent->UpdatePointerItem(0, item);
1847 pointerEvent->UpdatePointerItem(1, item2);
1848 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
1849 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
1850 return ERR_OK;
1851 }
1852
ProcessTouchPadGestureInput(int32_t argc,char * argv[],int32_t optionIndex)1853 int32_t InputManagerCommand::ProcessTouchPadGestureInput(int32_t argc, char *argv[], int32_t optionIndex)
1854 {
1855 struct option touchPadSensorOptions[] = {
1856 {"rotate", required_argument, nullptr, 'r'},
1857 {"swipe", required_argument, nullptr, 's'},
1858 {"pinch", required_argument, nullptr, 'p'},
1859 {nullptr, 0, nullptr, 0}
1860 };
1861 int32_t opt = 0;
1862 if ((opt = getopt_long(argc, argv, "r:s:p:", touchPadSensorOptions, &optionIndex)) != -1) {
1863 switch (opt) {
1864 case 'r': {
1865 int32_t ret = ProcessRotateGesture(argc, argv);
1866 if (ret != ERR_OK) {
1867 return ret;
1868 }
1869 break;
1870 }
1871 case 's': {
1872 int32_t ret = ProcessTouchPadFingerSwipe(argc, argv);
1873 if (ret != ERR_OK) {
1874 return ret;
1875 }
1876 break;
1877 }
1878 case 'p': {
1879 // uinput -P -p <finger count> <scale percent numerator> e.g. uinput -P -p 2 200
1880 int32_t ret = ProcessPinchGesture(argc, argv);
1881 if (ret != ERR_OK) {
1882 return ret;
1883 }
1884 break;
1885 }
1886 default: {
1887 std::cout << "invalid command" << std::endl;
1888 ShowUsage();
1889 return EVENT_REG_FAIL;
1890 }
1891 }
1892 }
1893 return ERR_OK;
1894 }
1895
ProcessRotateGesture(int32_t argc,char * argv[])1896 int32_t InputManagerCommand::ProcessRotateGesture(int32_t argc, char *argv[])
1897 {
1898 auto pointerEvent = PointerEvent::Create();
1899 CHKPR(pointerEvent, ERROR_NULL_POINTER);
1900 int32_t rotateValue = 0;
1901 constexpr int32_t paramNum = 4;
1902 constexpr int32_t conversionValue = 360;
1903 if (argc == paramNum) {
1904 if (!StrToInt(optarg, rotateValue)) {
1905 std::cout << "Invalid angle data" << std::endl;
1906 return RET_ERR;
1907 }
1908 if ((rotateValue >= conversionValue) || (rotateValue <= -(conversionValue))) {
1909 std::cout << "Rotate value must be within (-360,360)" << std::endl;
1910 return RET_ERR;
1911 }
1912 std::cout << "Input rotate value:"<<rotateValue << std::endl;
1913 pointerEvent->SetAxisValue(PointerEvent::AXIS_TYPE_ROTATE, rotateValue);
1914 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_ROTATE_END);
1915 pointerEvent->SetPointerId(0);
1916 PointerEvent::PointerItem item;
1917 item.SetPointerId(0);
1918 pointerEvent->AddPointerItem(item);
1919 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHPAD);
1920 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
1921 } else {
1922 std::cout << "Invalid angle data,Input parameter example: uinput - P - r 45" << std::endl;
1923 return RET_ERR;
1924 }
1925 return ERR_OK;
1926 }
1927
ProcessPinchGesture(int32_t argc,char * argv[])1928 int32_t InputManagerCommand::ProcessPinchGesture(int32_t argc, char *argv[])
1929 {
1930 CHKPR(argv, ERROR_NULL_POINTER);
1931 constexpr int32_t actionInputArgc = 6;
1932 constexpr int32_t minScaleNumerator = 0;
1933 constexpr int32_t maxScaleNumerator = 500;
1934 constexpr int32_t hundred = 100;
1935 constexpr int32_t fingerCount = 2;
1936 int32_t centerX = 0;
1937 int32_t centerY = 0;
1938 int32_t scalePercentNumerator = 0;
1939 std::string tips = "uinput -P -p dx, dy, scalePercent; dx, dy, scalePercent are all number.";
1940 std::string extralTips = " dx is bigger than 0 and dy is bigger than 200. 0 < scalePercent < 500;";
1941 if (optind < 0 || optind > argc) {
1942 std::cout << "wrong optind pointer index" << std::endl;
1943 std::cout << tips << extralTips << std::endl;
1944 return RET_ERR;
1945 }
1946 int32_t startPos = optind - MOVE_POS_ONE;
1947 if (argc == actionInputArgc) {
1948 if ((!StrToInt(argv[startPos], centerX)) ||
1949 (!StrToInt(argv[startPos + MOVE_POS_ONE], centerY)) ||
1950 (!StrToInt(argv[startPos + MOVE_POS_TWO], scalePercentNumerator))) {
1951 std::cout << tips << extralTips << std::endl;
1952 return RET_ERR;
1953 }
1954 } else {
1955 std::cout << tips << extralTips << std::endl;
1956 return RET_ERR;
1957 }
1958 if ((scalePercentNumerator <= minScaleNumerator) || (scalePercentNumerator > maxScaleNumerator)) {
1959 std::cout << "Invalid scale numberator:" << scalePercentNumerator << std::endl;
1960 std::cout << tips << extralTips << std::endl;
1961 return RET_ERR;
1962 }
1963 bool check = (centerX > 0) && (centerY >= hundred * fingerCount);
1964 if (!check) {
1965 std::cout << tips << extralTips << std::endl;
1966 return RET_ERR;
1967 }
1968 return ActionPinchEvent(centerX, centerY, scalePercentNumerator);
1969 }
1970
SwipeActionEvent(int32_t startX,int32_t startY,int32_t endX,int32_t endY)1971 int32_t InputManagerCommand::SwipeActionEvent(int32_t startX, int32_t startY, int32_t endX, int32_t endY)
1972 {
1973 constexpr int32_t fingerCount = 3;
1974 constexpr int32_t times = 10;
1975 constexpr int32_t thousand = 1000;
1976 int32_t disY = static_cast<int32_t>(static_cast<double>(endY - startY) / times);
1977 int32_t disX = static_cast<int32_t>(static_cast<double>(endX - startX) / times);
1978 int32_t actionType[10] = {PointerEvent::POINTER_ACTION_SWIPE_BEGIN};
1979 int64_t actionTimeBase = GetSysClockTime() - times * thousand * thousand;
1980 int64_t actionTimeStartTimeDis = fingerCount * thousand;
1981 int64_t actionStartTime[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
1982 int64_t actionTime[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
1983 int32_t sourceType = PointerEvent::SOURCE_TYPE_TOUCHPAD;
1984 actionTime[0] = actionTimeBase;
1985 actionStartTime[0] = (actionTimeBase - actionTimeStartTimeDis) / thousand;
1986 for (int32_t i = 1; i < times; i++) {
1987 actionStartTime[i] = actionStartTime[i - 1] + times - fingerCount;
1988 actionTime[i] = actionTime[i - 1] + times - fingerCount;
1989 actionType[i] = PointerEvent::POINTER_ACTION_SWIPE_UPDATE;
1990 }
1991 actionType[times - 1] = PointerEvent::POINTER_ACTION_SWIPE_END;
1992 for (int32_t i = 0; i < times; i++) {
1993 auto pointerEvent = CreateEvent(0, actionType[i], 0, sourceType, fingerCount);
1994 CHKPR(pointerEvent, ERROR_NULL_POINTER);
1995 pointerEvent->SetActionTime(actionTime[i]);
1996 pointerEvent->SetActionStartTime(actionStartTime[i]);
1997 PointerEvent::PointerItem item;
1998 item.SetDownTime(pointerEvent->GetActionStartTime());
1999 item.SetDisplayX(startX + disX * i);
2000 item.SetDisplayY(startY + disY * i);
2001 item.SetPointerId(0);
2002 pointerEvent->SetSourceType(sourceType);
2003 pointerEvent->AddPointerItem(item);
2004 pointerEvent->AddPointerItem(item);
2005 std::this_thread::sleep_for(std::chrono::microseconds(SLEEPTIME));
2006 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
2007 }
2008 return ERR_OK;
2009 }
2010
ProcessTouchPadFingerSwipe(int32_t argc,char * argv[])2011 int32_t InputManagerCommand::ProcessTouchPadFingerSwipe(int32_t argc, char *argv[])
2012 {
2013 constexpr int32_t actionInputArgc = 7;
2014 int32_t startX = 0;
2015 int32_t startY = 0;
2016 int32_t endX = 0;
2017 int32_t endY = 0;
2018 if (optind < 0 || optind > argc) {
2019 std::cout << "wrong optind pointer index" << std::endl;
2020 return RET_ERR;
2021 }
2022 int32_t startPos = optind - MOVE_POS_ONE;
2023 std::string tip = "uinput -P -s startX, startY, endX, endY;";
2024 std::string extralTip = "And startX, startY, endX, endY are all number which is bigger than 0;";
2025 if (argc == actionInputArgc) {
2026 if ((!StrToInt(argv[startPos], startX)) ||
2027 (!StrToInt(argv[startPos + MOVE_POS_ONE], startY)) ||
2028 (!StrToInt(argv[startPos + MOVE_POS_TWO], endX)) ||
2029 (!StrToInt(argv[startPos + MOVE_POS_THREE], endY))) {
2030 std::cout << tip << extralTip << std::endl;
2031 return RET_ERR;
2032 }
2033 } else {
2034 std::cout << tip << extralTip << std::endl;
2035 return RET_ERR;
2036 }
2037 bool check = (startX > 0) && (endX > 0) && (startY > 0) && (endY > 0);
2038 if (!check) {
2039 std::cout << tip << extralTip << std::endl;
2040 return RET_ERR;
2041 }
2042 return SwipeActionEvent(startX, startY, endX, endY);
2043 }
2044
CreateEvent(int32_t id,int32_t type,int32_t pointerId,int32_t sourceType,int32_t fingerCount)2045 std::shared_ptr<PointerEvent> InputManagerCommand::CreateEvent(
2046 int32_t id,
2047 int32_t type,
2048 int32_t pointerId,
2049 int32_t sourceType,
2050 int32_t fingerCount)
2051 {
2052 auto pointerEvent = PointerEvent::Create();
2053 CHKPP(pointerEvent);
2054 pointerEvent->SetId(id);
2055 pointerEvent->SetOriginPointerAction(type);
2056 pointerEvent->SetPointerAction(type);
2057 pointerEvent->SetPointerId(pointerId);
2058 pointerEvent->SetSourceType(sourceType);
2059 pointerEvent->SetFingerCount(fingerCount);
2060 return pointerEvent;
2061 }
2062
FillPointerItem(PointerEvent::PointerItem & item,int32_t pointX,int32_t pointY,int32_t id,bool press)2063 void InputManagerCommand::FillPointerItem(
2064 PointerEvent::PointerItem &item,
2065 int32_t pointX,
2066 int32_t pointY,
2067 int32_t id,
2068 bool press)
2069 {
2070 item.SetDisplayX(pointX);
2071 item.SetDisplayY(pointY);
2072 item.SetWindowX(pointX);
2073 item.SetWindowY(pointY);
2074 item.SetPointerId(id);
2075 item.SetPressed(press);
2076 }
2077
ActionPinchEvent(int32_t centerX,int32_t centerY,int32_t scalePercentNumerator)2078 int32_t InputManagerCommand::ActionPinchEvent(int32_t centerX, int32_t centerY, int32_t scalePercentNumerator)
2079 {
2080 CALL_DEBUG_ENTER;
2081 constexpr int32_t hundred = 100;
2082 constexpr int32_t fingerCount = 2;
2083 constexpr int32_t idSecondItem = 1;
2084 int32_t timesForSleep = hundred * hundred;
2085 int32_t distance = 0;
2086 int32_t times = hundred / (fingerCount * fingerCount * fingerCount);
2087 int32_t topX = centerX;
2088 int32_t bottomX = centerX;
2089 int32_t stepY = 0;
2090 int32_t actionType = PointerEvent::POINTER_ACTION_AXIS_BEGIN;
2091 double scalePinch = 1.0;
2092 if (scalePercentNumerator > hundred) {
2093 distance = hundred / fingerCount;
2094 stepY = 0 - (distance / (fingerCount * times));
2095 } else {
2096 distance = hundred * fingerCount;
2097 stepY = distance / (fingerCount * times);
2098 }
2099 int32_t topY = centerY - distance;
2100 int32_t bottomY = centerY + distance;
2101 double scalePinchChange = ((static_cast<double>(scalePercentNumerator) / hundred) - 1) / (times - 1);
2102 SendTouchDownForPinch(topX, topY, bottomX, bottomY);
2103 for (int32_t index = 0; index < times; index++) {
2104 if (index != 0) {
2105 actionType = PointerEvent::POINTER_ACTION_AXIS_UPDATE;
2106 scalePinch = scalePinch + scalePinchChange;
2107 }
2108 auto pointerEvent = CreateEvent(0, actionType, 0, PointerEvent::SOURCE_TYPE_TOUCHPAD, fingerCount);
2109 CHKPR(pointerEvent, ERROR_NULL_POINTER);
2110 pointerEvent->SetAxisValue(PointerEvent::AXIS_TYPE_PINCH, scalePinch);
2111 PointerEvent::PointerItem itemFirst;
2112 topY = topY + stepY;
2113 bottomY = bottomY - stepY;
2114 FillPointerItem(itemFirst, topX, topY, 0, false);
2115 itemFirst.SetToolType(PointerEvent::TOOL_TYPE_TOUCHPAD);
2116 itemFirst.SetDownTime(pointerEvent->GetActionStartTime());
2117 pointerEvent->AddPointerItem(itemFirst);
2118 PointerEvent::PointerItem itemSecond;
2119 FillPointerItem(itemSecond, bottomX, bottomY, idSecondItem, true);
2120 pointerEvent->SetPointerId(idSecondItem);
2121 pointerEvent->AddPointerItem(itemSecond);
2122 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
2123 std::this_thread::sleep_for(std::chrono::microseconds(SLEEPTIME * timesForSleep));
2124 }
2125 return RET_OK;
2126 }
2127
SendTouchDownForPinch(int32_t topX,int32_t topY,int32_t bottomX,int32_t bottomY)2128 void InputManagerCommand::SendTouchDownForPinch(int32_t topX, int32_t topY, int32_t bottomX, int32_t bottomY)
2129 {
2130 constexpr int32_t fingerCount = 2;
2131 int32_t itemId = 0;
2132 auto pointerEvent = CreateEvent(0, PointerEvent::POINTER_ACTION_DOWN, 0,
2133 PointerEvent::SOURCE_TYPE_TOUCHPAD, fingerCount);
2134 CHKPV(pointerEvent);
2135 pointerEvent->SetPointerId(itemId);
2136 PointerEvent::PointerItem itemFirst;
2137 FillPointerItem(itemFirst, topX, topY, itemId, true);
2138 itemFirst.SetToolType(PointerEvent::TOOL_TYPE_MOUSE);
2139 pointerEvent->AddPointerItem(itemFirst);
2140 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
2141 std::this_thread::sleep_for(std::chrono::microseconds(SLEEPTIME));
2142 pointerEvent = CreateEvent(0, PointerEvent::POINTER_ACTION_DOWN, 0,
2143 PointerEvent::SOURCE_TYPE_TOUCHPAD, fingerCount);
2144 CHKPV(pointerEvent);
2145 itemId = itemId + 1;
2146 pointerEvent->SetPointerId(itemId);
2147 PointerEvent::PointerItem itemSecond;
2148 FillPointerItem(itemSecond, bottomX, bottomY, itemId, true);
2149 pointerEvent->AddPointerItem(itemFirst);
2150 pointerEvent->AddPointerItem(itemSecond);
2151 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
2152 }
2153
PrintMouseUsage()2154 void InputManagerCommand::PrintMouseUsage()
2155 {
2156 std::cout << "-m <dx> <dy> --move <dx> <dy> -move to relative position (dx,dy)," << std::endl;
2157 std::cout << " <dx1> <dy1> <dx2> <dy2> [smooth time] --trace -dx1 dy1 to dx2 dy2 smooth movement" << std::endl;
2158 std::cout << "-d <key> --down key -press down a button, " << std::endl;
2159 std::cout << " 0 is the left button, 1 is the right," << std::endl;
2160 std::cout << " 2 is the middle" << std::endl;
2161 std::cout << "-u <key> --up <key> -release a button " << std::endl;
2162 std::cout << "-c <key> --click <key> -press the left button down,then raise" << std::endl;
2163 std::cout << "-b <dx1> <dy1> <id> [press time] [click interval time] --double click" << std::endl;
2164 std::cout << " [press time] the time range is more than 1ms but less than 300ms, " << std::endl;
2165 std::cout << " [click interval time] the time range is more than 1ms but less than 450ms, " << std::endl;
2166 std::cout << " Otherwise the operation result may produce error or invalid operation" << std::endl;
2167 std::cout << " -press the left button down,then raise" << std::endl;
2168 std::cout << " key value:0 - button left" << std::endl;
2169 std::cout << " key value:1 - button right" << std::endl;
2170 std::cout << " key value:2 - button middle" << std::endl;
2171 std::cout << " key value:3 - button side" << std::endl;
2172 std::cout << " key value:4 - button extra" << std::endl;
2173 std::cout << " key value:5 - button forward" << std::endl;
2174 std::cout << " key value:6 - button back" << std::endl;
2175 std::cout << " key value:7 - button task" << std::endl;
2176 std::cout << "-s <key> --scroll <key> -positive values are sliding backwards" << std::endl;
2177 std::cout << "-g <dx1> <dy1> <dx2> <dy2> [total time] --drag <dx1> <dy1> <dx2> <dy2> [total time],";
2178 std::cout << std::endl;
2179 std::cout << " dx1 dy1 to dx2 dy2 smooth drag" << std::endl;
2180 std::cout << "-i <time> --interval <time> -the program interval for the (time) milliseconds";
2181 std::cout << std::endl;
2182 std::cout << " negative values are sliding forwards" << std::endl;
2183 }
2184
PrintKeyboardUsage()2185 void InputManagerCommand::PrintKeyboardUsage()
2186 {
2187 std::cout << "-d <key> --down <key> -press down a key" << std::endl;
2188 std::cout << "-u <key> --up <key> -release a key " << std::endl;
2189 std::cout << "-l <key> [long press time] --long_press <key> [long press time] -press and hold the key";
2190 std::cout << std::endl;
2191 std::cout << "-r <key> [repeat output time] --repeat output <key> [repeat output time] -press and hold the key";
2192 std::cout << std::endl;
2193 std::cout << "-i <time> --interval <time> -the program interval for the (time) milliseconds";
2194 std::cout << std::endl;
2195 }
2196
PrintStylusUsage()2197 void InputManagerCommand::PrintStylusUsage()
2198 {
2199 std::cout << "-d <dx1> <dy1> --down <dx1> <dy1> -press down a position dx1 dy1, " << std::endl;
2200 std::cout << "-u <dx1> <dy1> --up <dx1> <dy1> -release a position dx1 dy1, " << std::endl;
2201 std::cout << "-i <time> --interval <time> -the program interval for the (time) milliseconds";
2202 std::cout << std::endl;
2203 std::cout << "-m <dx1> <dy1> <dx2> <dy2> [smooth time] --smooth movement" << std::endl;
2204 std::cout << " <dx1> <dy1> <dx2> <dy2> [smooth time] -smooth movement, " << std::endl;
2205 std::cout << " dx1 dy1 to dx2 dy2 smooth movement" << std::endl;
2206 std::cout << "-c <dx1> <dy1> [click interval] -touch screen click dx1 dy1" << std::endl;
2207 std::cout << "-g <dx1> <dy1> <dx2> <dy2> [press time] [total time] -drag, " << std::endl;
2208 std::cout << " [Press time] not less than 500ms and [total time] - [Press time] not less than 500ms" << std::endl;
2209 std::cout << " Otherwise the operation result may produce error or invalid operation" << std::endl;
2210 }
2211
PrintTouchUsage()2212 void InputManagerCommand::PrintTouchUsage()
2213 {
2214 std::cout << "-d <dx1> <dy1> --down <dx1> <dy1> -press down a position dx1 dy1, " << std::endl;
2215 std::cout << "-u <dx1> <dy1> --up <dx1> <dy1> -release a position dx1 dy1, " << std::endl;
2216 std::cout << "-i <time> --interval <time> -the program interval for the (time) milliseconds";
2217 std::cout << std::endl;
2218 std::cout << "-m <dx1> <dy1> <dx2> <dy2> [-k keep time] [smooth time] --smooth movement, keep time:keep time";
2219 std::cout << std::endl;
2220 std::cout << " after moving, the max value is 60000 ";
2221 std::cout << std::endl;
2222 std::cout << " ms, default value is 0; smooth time:";
2223 std::cout << std::endl;
2224 std::cout << " move time, default value is 1000 ms";
2225 std::cout << std::endl;
2226 std::cout << " Support for multiple finger movements at the same time, for example:" << std::endl;
2227 std::cout << " uinput -T -m 300 900 600 900 900 900 600 900, (300, 900) move to (600, 900), (900, 900) move to";
2228 std::cout << std::endl;
2229 std::cout << " (600, 900)" << std::endl;
2230 std::cout << "-c <dx1> <dy1> [click interval] -touch screen click dx1 dy1" << std::endl;
2231 std::cout << "-k --knuckle " << std::endl;
2232 std::cout << "commands for knucle: " << std::endl;
2233 PrintKnuckleUsage();
2234 std::cout << std::endl;
2235 std::cout << "-g <dx1> <dy1> <dx2> <dy2> [press time] [total time] -drag, " << std::endl;
2236 std::cout << " [Press time] not less than 500ms and [total time] - [Press time] not less than 500ms" << std::endl;
2237 std::cout << " Otherwise the operation result may produce error or invalid operation" << std::endl;
2238 }
2239
PrintKnuckleUsage()2240 void InputManagerCommand::PrintKnuckleUsage()
2241 {
2242 std::cout << "-s <dx1> <dy1> <dx2> <dy2> [interval time] --single knuckle double click interval time" << std::endl;
2243 std::cout << "-d <dx1> <dy1> <dx2> <dy2> [interval time] --double knuckle double click interval time" << std::endl;
2244 std::cout << "-i <time> --interval <time> -the program interval for the (time) milliseconds";
2245 }
2246
PrintTouchPadUsage()2247 void InputManagerCommand::PrintTouchPadUsage()
2248 {
2249 std::cout << "-p dx, dy, scalePercent; dx, dy, scalePercent are all number." << std::endl;
2250 std::cout << "dx is bigger than 0 and dy is bigger than 200. 0 < scalePercent < 500;" << std::endl;
2251 std::cout << "While simulate this, make sure that a picture is on the top of the desktop." << std::endl;
2252 std::cout << "-s startX, startY, endX, endY;" << std::endl;
2253 std::cout << "And startX, startY, endX, endY are all number which is bigger than 0;" << std::endl;
2254 std::cout << "While simulate this, make sure that your actual action is available" << std::endl;
2255 std::cout << "-r <rotate value> rotate value must be within (-360,360)" << std::endl;
2256 }
2257
ShowUsage()2258 void InputManagerCommand::ShowUsage()
2259 {
2260 std::cout << "Usage: uinput <option> <command> <arg>..." << std::endl;
2261 std::cout << "The option are: " << std::endl;
2262 std::cout << "-K --keyboard " << std::endl;
2263 std::cout << "commands for keyboard: " << std::endl;
2264 PrintKeyboardUsage();
2265 std::cout << std::endl;
2266
2267 std::cout << "-M --mouse " << std::endl;
2268 std::cout << "commands for mouse: " << std::endl;
2269 PrintMouseUsage();
2270 std::cout << std::endl;
2271
2272 std::cout << "-P --touchpad " << std::endl;
2273 std::cout << "commands for touchpad: " << std::endl;
2274 PrintTouchPadUsage();
2275
2276 std::cout << "-S --stylus " << std::endl;
2277 std::cout << "commands for stylus: " << std::endl;
2278 PrintStylusUsage();
2279 std::cout << std::endl;
2280
2281 std::cout << "-T --touch " << std::endl;
2282 std::cout << "commands for touch: " << std::endl;
2283 PrintTouchUsage();
2284 std::cout << std::endl;
2285
2286 std::cout << " " << std::endl;
2287 std::cout << "-? --help " << std::endl;
2288 }
2289 } // namespace MMI
2290 } // namespace OHOS
2291