1 /*
2 * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "input_manager_command.h"
17
18 #include <getopt.h>
19
20 #include <algorithm>
21 #include <chrono>
22 #include <cmath>
23 #include <cstdio>
24 #include <cstdlib>
25 #include <ctime>
26 #include <iostream>
27 #include <limits>
28 #include <thread>
29
30 #include <sys/time.h>
31 #include <unistd.h>
32
33 #include "string_ex.h"
34
35 #include "error_multimodal.h"
36 #include "event_log_helper.h"
37 #include "input_manager.h"
38 #include "mmi_log.h"
39 #include "multimodal_event_handler.h"
40 #include "util.h"
41
42 #undef MMI_LOG_TAG
43 #define MMI_LOG_TAG "InputManagerCommand"
44
45 class InputManagerCommand {
46 public:
47 int32_t ParseCommand(int32_t argc, char *argv[]);
48 int32_t ConnectService();
49 void ShowUsage();
50 private:
51 void InitializeMouseDeathStub();
52 };
53 namespace OHOS {
54 namespace MMI {
55 namespace {
56 constexpr int32_t SLEEPTIME = 20;
57 constexpr int32_t MOUSE_ID = 7;
58 constexpr int32_t JOYSTICK_BUTTON_ID = 25;
59 constexpr int32_t TWO_MORE_COMMAND = 2;
60 constexpr int32_t THREE_MORE_COMMAND = 3;
61 constexpr int32_t MAX_PRESSED_COUNT = 30;
62 constexpr int32_t ACTION_TIME = 3000;
63 constexpr int32_t BLOCK_TIME_MS = 7;
64 constexpr int32_t TIME_TRANSITION = 1000;
65 constexpr int64_t MIN_TAKTTIME_MS = 1;
66 constexpr int64_t MAX_TAKTTIME_MS = 15000;
67 constexpr int32_t DEFAULT_DELAY = 200;
68 constexpr int32_t KNUCKLE_PARAM_SIZE = 9;
69 constexpr int32_t DEFAULT_POINTER_ID_FIRST = 0;
70 constexpr int32_t TOTAL_TIME_MS = 1000;
71 constexpr int32_t BUTTON_PARAM_SIZE = 8;
72 constexpr int32_t KEY_PARAM_SIZE = 5;
73 constexpr int32_t KEY_TIME_PARAM_SIZE = 6;
74 constexpr int32_t INTERVAL_TIME_MS = 100;
75 constexpr int32_t FINGER_LOCATION_NUMS = 4;
76 constexpr int32_t MOVE_POS_ONE = 1;
77 constexpr int32_t MOVE_POS_TWO = 2;
78 constexpr int32_t MOVE_POS_THREE = 3;
79 constexpr int32_t MAX_KEEP_TIME = 60000;
80 constexpr int32_t NUM_KEEP_ARGC = 2;
81 constexpr int32_t MAX_ARGC = 18;
82 constexpr int32_t ONE_ARGC = 1;
83 constexpr int32_t TWO_ARGC = 2;
84 constexpr int32_t THREE_ARGC = 3;
85 constexpr int32_t FOUR_ARGC = 4;
86
87 enum JoystickEvent {
88 JOYSTICK_BUTTON_UP,
89 JOYSTICK_BUTTON_PRESS,
90 JOYSTICK_MOVE,
91 JOYSTICK_CLICK,
92 JOYSTICK_INTERVAL
93 };
94 struct JoystickInfo {
95 int32_t buttonId { -1 };
96 int32_t absValue { -1 };
97 int32_t taktTime { 0 };
98 PointerEvent::AxisType absType;
99 };
100 } // namespace
101
SleepAndUpdateTime(int64_t & currentTimeMs)102 void InputManagerCommand::SleepAndUpdateTime(int64_t ¤tTimeMs)
103 {
104 int64_t nowEndSysTimeMs = GetSysClockTime() / TIME_TRANSITION;
105 int64_t sleepTimeMs = BLOCK_TIME_MS - (nowEndSysTimeMs - currentTimeMs) % BLOCK_TIME_MS;
106 std::this_thread::sleep_for(std::chrono::milliseconds(sleepTimeMs));
107 currentTimeMs = nowEndSysTimeMs + sleepTimeMs;
108 }
109
NextPos(int64_t begTimeMs,int64_t curtTimeMs,int32_t totalTimeMs,int32_t begPos,int32_t endPos)110 int32_t InputManagerCommand::NextPos(int64_t begTimeMs, int64_t curtTimeMs, int32_t totalTimeMs,
111 int32_t begPos, int32_t endPos)
112 {
113 int64_t endTimeMs = 0;
114 if (!AddInt64(begTimeMs, totalTimeMs, endTimeMs)) {
115 return begPos;
116 }
117 if (curtTimeMs < begTimeMs || curtTimeMs > endTimeMs) {
118 return begPos;
119 }
120 if (totalTimeMs == 0) {
121 std::cout << "invalid totalTimeMs" << std::endl;
122 return begPos;
123 }
124 double tmpTimeMs = static_cast<double>(curtTimeMs - begTimeMs) / totalTimeMs;
125 int32_t offsetPos = std::ceil(tmpTimeMs * (endPos - begPos));
126 int32_t retPos = 0;
127 if (offsetPos == 0) {
128 return begPos;
129 } else if (offsetPos > 0) {
130 if (!AddInt32(begPos, offsetPos, retPos)) {
131 return begPos;
132 }
133 return retPos > endPos ? endPos : retPos;
134 }
135 if (!AddInt32(begPos, offsetPos, retPos)) {
136 return begPos;
137 }
138 return retPos < endPos ? endPos : retPos;
139 }
140
ParseCommand(int32_t argc,char * argv[])141 int32_t InputManagerCommand::ParseCommand(int32_t argc, char *argv[])
142 {
143 struct option headOptions[] = {
144 {"mouse", no_argument, nullptr, 'M'},
145 {"keyboard", no_argument, nullptr, 'K'},
146 {"stylus", no_argument, nullptr, 'S'},
147 {"touch", no_argument, nullptr, 'T'},
148 {"touchpad", no_argument, nullptr, 'P'},
149 {"joystick", no_argument, nullptr, 'J'},
150 {"help", no_argument, nullptr, '?'},
151 {nullptr, 0, nullptr, 0}
152 };
153
154 struct option mouseSensorOptions[] = {
155 {"move", required_argument, nullptr, 'm'},
156 {"click", required_argument, nullptr, 'c'},
157 {"double_click", required_argument, nullptr, 'b'},
158 {"down", required_argument, nullptr, 'd'},
159 {"up", required_argument, nullptr, 'u'},
160 {"scroll", required_argument, nullptr, 's'},
161 {"drag", required_argument, nullptr, 'g'},
162 {"interval", required_argument, nullptr, 'i'},
163 {nullptr, 0, nullptr, 0}
164 };
165 struct option keyboardSensorOptions[] = {
166 {"down", required_argument, nullptr, 'd'},
167 {"up", required_argument, nullptr, 'u'},
168 {"long_press", required_argument, nullptr, 'l'},
169 {"repeat", required_argument, nullptr, 'r'},
170 {"interval", required_argument, nullptr, 'i'},
171 {"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