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