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 ¤tTimeMs)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 buttonsId = 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.SetDisplayY(py1);
629 item.SetDisplayX(px1);
630 item.SetPressed(false);
631 item.SetPointerId(0);
632 pointerEvent->SetButtonPressed(0);
633 pointerEvent->AddPointerItem(item);
634 pointerEvent->SetButtonId(buttonsId);
635 pointerEvent->SetButtonPressed(buttonsId);
636 pointerEvent->SetPointerId(0);
637 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
638 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_BUTTON_DOWN);
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("KeyCode:%{private}d, ActionTime:%{public}" PRId64
904 ",KeyAction:%{public}s, IsRepeat:%{public}s",
905 keyEventTemp->GetKeyCode(), keyEventTemp->GetActionTime(),
906 KeyEvent::ActionToString(keyEventTemp->GetKeyAction()), isRepeat.c_str());
907 }
908 InputManager::GetInstance()->SimulateInputEvent(keyEventTemp);
909 std::this_thread::sleep_for(std::chrono::milliseconds(pressTimeMs));
910
911 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_UP);
912 item.SetPressed(false);
913 keyEvent->AddKeyItem(item);
914 time = GetSysClockTime();
915 keyEvent->SetActionTime(time);
916 keyEvent->SetRepeat(true);
917 isRepeat = keyEvent->IsRepeat() ? "true" : "false";
918 if (!OHOS::MMI::EventLogHelper::IsBetaVersion()) {
919 MMI_HILOGI("KeyAction:%{public}s, IsRepeat:%{public}s",
920 KeyEvent::ActionToString(keyEvent->GetKeyAction()), isRepeat.c_str());
921 } else {
922 MMI_HILOGI("KeyCode:%{private}d, ActionTime:%{public}" PRId64
923 ",KeyAction:%{public}s, IsRepeat:%{public}s",
924 keyEvent->GetKeyCode(), keyEvent->GetActionTime(),
925 KeyEvent::ActionToString(keyEvent->GetKeyAction()), isRepeat.c_str());
926 }
927 InputManager::GetInstance()->SimulateInputEvent(keyEvent);
928 break;
929 }
930 case 'i': {
931 int32_t taktTime = 0;
932 if (!StrToInt(optarg, taktTime)) {
933 std::cout << "invalid command to interval time" << std::endl;
934 return EVENT_REG_FAIL;
935 }
936 const int64_t minTaktTimeMs = 1;
937 const int64_t maxTaktTimeMs = 15000;
938 if ((minTaktTimeMs > taktTime) || (maxTaktTimeMs < taktTime)) {
939 std::cout << "taktTime is error" << std::endl;
940 std::cout << minTaktTimeMs << " < taktTime < " << maxTaktTimeMs;
941 std::cout << std::endl;
942 return EVENT_REG_FAIL;
943 }
944 std::this_thread::sleep_for(std::chrono::milliseconds(taktTime));
945 break;
946 }
947 case 't': {
948 int32_t ret = ProcessKeyboardTextInput(optarg, count);
949 if (ret != ERR_OK) {
950 return ret;
951 }
952 inputText = true;
953 break;
954 }
955 default: {
956 std::cout << "invalid command to keyboard key" << std::endl;
957 ShowUsage();
958 return EVENT_REG_FAIL;
959 }
960 }
961 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEPTIME));
962 count++;
963 }
964 for (size_t i = 0; i < downKey.size(); i++) {
965 std::cout << "you have a key " << downKey[i] << " not release" << std::endl;
966 }
967 break;
968 }
969 case 'S':
970 case 'T': {
971 int32_t px1 = 0;
972 int32_t py1 = 0;
973 int32_t px2 = 0;
974 int32_t py2 = 0;
975 int32_t totalTimeMs = 0;
976 int32_t moveArgcSeven = 7;
977 int32_t firstOpt = c;
978 while ((c = getopt_long(argc, argv, "m:d:u:c:i:g:k", touchSensorOptions, &optionIndex)) != -1) {
979 switch (c) {
980 case 'm': {
981 if (argc < moveArgcSeven || argc > MAX_ARGC) {
982 std::cout << "wrong number of parameters:" << argc << std::endl;
983 return EVENT_REG_FAIL;
984 }
985 struct FingerInfo {
986 int32_t startX = 0;
987 int32_t startY = 0;
988 int32_t endX = 0;
989 int32_t endY = 0;
990 };
991 int32_t startX = 0;
992 int32_t startY = 0;
993 int32_t endX = 0;
994 int32_t endY = 0;
995 int32_t totalTimeMs = 0;
996 int32_t keepTimeMs = 0;
997 int32_t fingerCount = 0;
998 std::vector<FingerInfo> fingerList;
999 int32_t startPos = optind - MOVE_POS_ONE;
1000 while (true) {
1001 int32_t residueArgc = argc - startPos;
1002 if (residueArgc == 0) {
1003 totalTimeMs = TOTAL_TIME_MS;
1004 optind = startPos;
1005 break;
1006 } else if (residueArgc == ONE_ARGC) {
1007 if (!StrToInt(argv[startPos], totalTimeMs)) {
1008 std::cout << "invalid total times" << std::endl;
1009 return EVENT_REG_FAIL;
1010 }
1011 optind = startPos + MOVE_POS_ONE;
1012 break;
1013 } else if (residueArgc == TWO_ARGC) {
1014 totalTimeMs = TOTAL_TIME_MS;
1015 if ((strlen(argv[startPos]) != NUM_KEEP_ARGC) ||
1016 (argv[startPos][0] != '-') ||
1017 (argv[startPos][1] != 'k') ||
1018 (!StrToInt(argv[startPos + MOVE_POS_ONE], keepTimeMs))) {
1019 std::cout << "invalid keep times" << std::endl;
1020 return EVENT_REG_FAIL;
1021 }
1022 optind = startPos + MOVE_POS_TWO;
1023 break;
1024 } else if (residueArgc == THREE_ARGC) {
1025 if (strlen(argv[startPos]) == NUM_KEEP_ARGC) {
1026 if ((argv[startPos][0] != '-') ||
1027 (argv[startPos][1] != 'k') ||
1028 (!StrToInt(argv[startPos + MOVE_POS_ONE], keepTimeMs))) {
1029 std::cout << "invalid keep times" << std::endl;
1030 return EVENT_REG_FAIL;
1031 }
1032 if (!StrToInt(argv[startPos + MOVE_POS_TWO], totalTimeMs)) {
1033 std::cout << "invalid total times" << std::endl;
1034 return EVENT_REG_FAIL;
1035 }
1036 } else {
1037 if (!StrToInt(argv[startPos], totalTimeMs)) {
1038 std::cout << "invalid total times" << std::endl;
1039 return EVENT_REG_FAIL;
1040 }
1041 if ((argv[startPos + MOVE_POS_ONE][0] != '-') ||
1042 (argv[startPos + MOVE_POS_ONE][1] != 'k') ||
1043 (!StrToInt(argv[startPos + MOVE_POS_TWO], keepTimeMs))) {
1044 std::cout << "invalid keep times" << std::endl;
1045 return EVENT_REG_FAIL;
1046 }
1047 }
1048 optind = startPos + MOVE_POS_THREE;
1049 break;
1050 } else if (residueArgc >= FOUR_ARGC) {
1051 if ((!StrToInt(argv[startPos], startX)) ||
1052 (!StrToInt(argv[startPos + MOVE_POS_ONE], startY)) ||
1053 (!StrToInt(argv[startPos + MOVE_POS_TWO], endX)) ||
1054 (!StrToInt(argv[startPos + MOVE_POS_THREE], endY))) {
1055 std::cout << "invalid coordinate value" << std::endl;
1056 return EVENT_REG_FAIL;
1057 }
1058 if ((startX < 0) || (startY < 0) || (endX < 0) || (endY < 0)) {
1059 std::cout << "Coordinate value must be greater or equal than 0" << std::endl;
1060 return RET_ERR;
1061 }
1062 FingerInfo fingerInfoTemp {
1063 .startX = startX,
1064 .startY = startY,
1065 .endX = endX,
1066 .endY = endY
1067 };
1068 fingerList.push_back(fingerInfoTemp);
1069 fingerCount += 1;
1070 startPos += FINGER_LOCATION_NUMS;
1071 optind += THREE_MORE_COMMAND;
1072 } else {
1073 std::cout << "invalid total times" << std::endl;
1074 return EVENT_REG_FAIL;
1075 }
1076 }
1077
1078 for (const auto &finger : fingerList) {
1079 std::cout << "startX:" << finger.startX << ", startY:" << finger.startY <<
1080 ", endX:" << finger.endX << ", endY:" << finger.endY << std::endl;
1081 }
1082 if (keepTimeMs > MAX_KEEP_TIME || keepTimeMs < 0) {
1083 std::cout << "invalid keep times" << std::endl;
1084 return EVENT_REG_FAIL;
1085 }
1086 if (totalTimeMs < 0) {
1087 std::cout << "invalid total times" << std::endl;
1088 return EVENT_REG_FAIL;
1089 }
1090 std::cout << "fingerCount:" << fingerCount <<std::endl;
1091 std::cout << "keepTimeMs:" << keepTimeMs <<std::endl;
1092 std::cout << "totalTimeMs:" << totalTimeMs <<std::endl;
1093
1094 const int64_t minTotalTimeMs = 1;
1095 const int64_t maxTotalTimeMs = 15000;
1096 if ((totalTimeMs < minTotalTimeMs) || (totalTimeMs > maxTotalTimeMs)) {
1097 std::cout << "total time is out of range:" << std::endl;
1098 std::cout << minTotalTimeMs << " <= " << "total times" << " <= " << maxTotalTimeMs;
1099 std::cout << std::endl;
1100 return EVENT_REG_FAIL;
1101 }
1102
1103 auto pointerEvent = PointerEvent::Create();
1104 CHKPR(pointerEvent, ERROR_NULL_POINTER);
1105 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
1106 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
1107 for (int32_t i = 0; i < fingerCount; i++) {
1108 PointerEvent::PointerItem item;
1109 item.SetDisplayX(fingerList[i].startX);
1110 item.SetDisplayY(fingerList[i].startY);
1111 item.SetRawDisplayX(fingerList[i].startX);
1112 item.SetRawDisplayY(fingerList[i].startY);
1113 item.SetPointerId(DEFAULT_POINTER_ID_FIRST + i);
1114 pointerEvent->AddPointerItem(item);
1115 pointerEvent->SetPointerId(DEFAULT_POINTER_ID_FIRST + i);
1116 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
1117 }
1118
1119 int64_t startTimeUs = pointerEvent->GetActionStartTime();
1120 int64_t startTimeMs = startTimeUs / TIME_TRANSITION;
1121 int64_t endTimeMs = 0;
1122 if (!AddInt64(startTimeMs, totalTimeMs, endTimeMs)) {
1123 std::cout << "system time error." << std::endl;
1124 return EVENT_REG_FAIL;
1125 }
1126 int64_t currentTimeMs = startTimeMs;
1127 int64_t nowSysTimeUs = 0;
1128 int64_t nowSysTimeMs = 0;
1129 int64_t sleepTimeMs = 0;
1130
1131 std::vector<int32_t> pointerIds = pointerEvent->GetPointerIds();
1132 if (pointerIds.size() != static_cast<size_t>(fingerCount)) {
1133 std::cout << "pointerIds size is error" << std::endl;
1134 return EVENT_REG_FAIL;
1135 }
1136
1137 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
1138 while (currentTimeMs < endTimeMs) {
1139 for (size_t i = 0; i < pointerIds.size(); i++) {
1140 int32_t pointerId = pointerIds[i];
1141 PointerEvent::PointerItem item;
1142 if (!pointerEvent->GetPointerItem(pointerId, item)) {
1143 std::cout << "Invalid pointer:" << pointerId << std::endl;
1144 return EVENT_REG_FAIL;
1145 }
1146 item.SetDisplayX(NextPos(startTimeMs, currentTimeMs, totalTimeMs,
1147 fingerList[i].startX, fingerList[i].endX));
1148 item.SetDisplayY(NextPos(startTimeMs, currentTimeMs, totalTimeMs,
1149 fingerList[i].startY, fingerList[i].endY));
1150 item.SetRawDisplayX(NextPos(startTimeMs, currentTimeMs, totalTimeMs,
1151 fingerList[i].startX, fingerList[i].endX));
1152 item.SetRawDisplayY(NextPos(startTimeMs, currentTimeMs, totalTimeMs,
1153 fingerList[i].startY, fingerList[i].endY));
1154 pointerEvent->UpdatePointerItem(pointerId, item);
1155 pointerEvent->SetPointerId(pointerId);
1156 pointerEvent->SetActionTime(currentTimeMs * TIME_TRANSITION);
1157 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
1158 }
1159 nowSysTimeUs = GetSysClockTime();
1160 nowSysTimeMs = nowSysTimeUs / TIME_TRANSITION;
1161 sleepTimeMs = (currentTimeMs + BLOCK_TIME_MS) - nowSysTimeMs;
1162 std::this_thread::sleep_for(std::chrono::milliseconds(sleepTimeMs));
1163 currentTimeMs += BLOCK_TIME_MS;
1164 }
1165
1166 for (size_t i = 0; i < pointerIds.size(); i++) {
1167 int32_t pointerId = pointerIds[i];
1168 PointerEvent::PointerItem item;
1169 if (!pointerEvent->GetPointerItem(pointerId, item)) {
1170 std::cout << "Invalid pointer:" << pointerId << std::endl;
1171 return EVENT_REG_FAIL;
1172 }
1173 item.SetDisplayX(fingerList[i].endX);
1174 item.SetDisplayY(fingerList[i].endY);
1175 item.SetRawDisplayX(fingerList[i].endX);
1176 item.SetRawDisplayY(fingerList[i].endY);
1177 pointerEvent->UpdatePointerItem(pointerId, item);
1178 pointerEvent->SetPointerId(pointerId);
1179 pointerEvent->SetActionTime(currentTimeMs * TIME_TRANSITION);
1180 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
1181 }
1182 std::this_thread::sleep_for(std::chrono::milliseconds(BLOCK_TIME_MS));
1183
1184 if (keepTimeMs > 0) {
1185 currentTimeMs = GetSysClockTime() / TIME_TRANSITION;
1186 int64_t keepEndTimeMs = 0;
1187 if (!AddInt64(currentTimeMs, keepTimeMs, keepEndTimeMs)) {
1188 std::cout << "system time error." << std::endl;
1189 return EVENT_REG_FAIL;
1190 }
1191 while (currentTimeMs < keepEndTimeMs) {
1192 for (size_t i = 0; i < pointerIds.size(); i++) {
1193 int32_t pointerId = pointerIds[i];
1194 PointerEvent::PointerItem item;
1195 if (!pointerEvent->GetPointerItem(pointerId, item)) {
1196 std::cout << "Invalid pointer:" << pointerId << std::endl;
1197 return EVENT_REG_FAIL;
1198 }
1199 item.SetDisplayX(fingerList[i].endX);
1200 item.SetDisplayY(fingerList[i].endY);
1201 item.SetRawDisplayX(fingerList[i].endX);
1202 item.SetRawDisplayY(fingerList[i].endY);
1203 pointerEvent->UpdatePointerItem(pointerId, item);
1204 pointerEvent->SetPointerId(pointerId);
1205 pointerEvent->SetActionTime(currentTimeMs * TIME_TRANSITION);
1206 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
1207 }
1208 nowSysTimeUs = GetSysClockTime();
1209 nowSysTimeMs = nowSysTimeUs / TIME_TRANSITION;
1210 sleepTimeMs = (currentTimeMs + BLOCK_TIME_MS) - nowSysTimeMs;
1211 std::this_thread::sleep_for(std::chrono::milliseconds(sleepTimeMs));
1212 currentTimeMs += BLOCK_TIME_MS;
1213 }
1214 }
1215
1216 pointerEvent->SetActionTime((endTimeMs + BLOCK_TIME_MS) * TIME_TRANSITION);
1217 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
1218 for (size_t i = 0; i < pointerIds.size(); i++) {
1219 int32_t pointerId = pointerIds[i];
1220 PointerEvent::PointerItem item;
1221 if (!pointerEvent->GetPointerItem(pointerId, item)) {
1222 std::cout << "Invalid pointer:" << pointerId << std::endl;
1223 return EVENT_REG_FAIL;
1224 }
1225 pointerEvent->UpdatePointerItem(pointerId, item);
1226 pointerEvent->SetPointerId(pointerId);
1227 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
1228 pointerEvent->RemovePointerItem(pointerId);
1229 }
1230 break;
1231 }
1232 case 'd': {
1233 if (optind >= argc) {
1234 std::cout << "too few arguments to function" << std::endl;
1235 return EVENT_REG_FAIL;
1236 }
1237 if (!StrToInt(optarg, px1) || !StrToInt(argv[optind], py1)) {
1238 std::cout << "invalid coordinate value" << std::endl;
1239 return EVENT_REG_FAIL;
1240 }
1241 if ((px1 < 0) || (py1 < 0)) {
1242 std::cout << "Coordinate value must be greater or equal than 0" << std::endl;
1243 return RET_ERR;
1244 }
1245 std::cout << "touch down " << px1 << " " << py1 << std::endl;
1246 auto pointerEvent = PointerEvent::Create();
1247 CHKPR(pointerEvent, ERROR_NULL_POINTER);
1248 PointerEvent::PointerItem item;
1249 item.SetDisplayY(py1);
1250 item.SetRawDisplayY(py1);
1251 item.SetPointerId(DEFAULT_POINTER_ID_FIRST);
1252 item.SetDisplayX(px1);
1253 item.SetRawDisplayX(px1);
1254 pointerEvent->SetPointerId(DEFAULT_POINTER_ID_FIRST);
1255 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
1256 pointerEvent->AddPointerItem(item);
1257 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
1258 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
1259 optind++;
1260 break;
1261 }
1262 case 'u': {
1263 if (optind >= argc) {
1264 std::cout << "too few arguments to function" << std::endl;
1265 return EVENT_REG_FAIL;
1266 }
1267 if (!StrToInt(optarg, px1) || !StrToInt(argv[optind], py1)) {
1268 std::cout << "invalid coordinate value" << std::endl;
1269 return EVENT_REG_FAIL;
1270 }
1271 if ((px1 < 0) || (py1 < 0)) {
1272 std::cout << "Coordinate value must be greater or equal than 0" << std::endl;
1273 return RET_ERR;
1274 }
1275 std::cout << "touch up " << px1 << " " << py1 << std::endl;
1276 auto pointerEvent = PointerEvent::Create();
1277 CHKPR(pointerEvent, ERROR_NULL_POINTER);
1278 PointerEvent::PointerItem item;
1279 item.SetDisplayY(py1);
1280 item.SetRawDisplayY(py1);
1281 item.SetPointerId(DEFAULT_POINTER_ID_FIRST);
1282 item.SetDisplayX(px1);
1283 item.SetRawDisplayX(px1);
1284 pointerEvent->SetPointerId(DEFAULT_POINTER_ID_FIRST);
1285 pointerEvent->AddPointerItem(item);
1286 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
1287 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
1288 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
1289 optind++;
1290 break;
1291 }
1292 case 'c': {
1293 int32_t intervalTimeMs = 0;
1294 if (argc == KEY_PARAM_SIZE) {
1295 if (!StrToInt(optarg, px1) ||
1296 !StrToInt(argv[optind], py1)) {
1297 std::cout << "input coordinate error" << std::endl;
1298 return RET_ERR;
1299 }
1300 intervalTimeMs = INTERVAL_TIME_MS;
1301 } else if (argc == KEY_TIME_PARAM_SIZE) {
1302 if (!StrToInt(optarg, px1) ||
1303 !StrToInt(argv[optind], py1) ||
1304 !StrToInt(argv[optind + 1], intervalTimeMs)) {
1305 std::cout << "input coordinate or time error" << std::endl;
1306 return RET_ERR;
1307 }
1308 const int64_t minIntervalTimeMs = 1;
1309 const int64_t maxIntervalTimeMs = 450;
1310 if ((minIntervalTimeMs > intervalTimeMs) || (maxIntervalTimeMs < intervalTimeMs)) {
1311 std::cout << "interval time is out of range: " << minIntervalTimeMs << "ms";
1312 std::cout << " < interval time < " << maxIntervalTimeMs << "ms" << std::endl;
1313 return RET_ERR;
1314 }
1315 } else {
1316 std::cout << "parameter error, unable to run" << std::endl;
1317 return RET_ERR;
1318 }
1319 if ((px1 < 0) || (py1 < 0)) {
1320 std::cout << "Coordinate value must be greater or equal than 0" << std::endl;
1321 return RET_ERR;
1322 }
1323 std::cout << " click coordinate: ("<< px1 << ", " << py1 << ")" << std::endl;
1324 std::cout << "click interval time: " << intervalTimeMs << "ms" << std::endl;
1325 auto pointerEvent = PointerEvent::Create();
1326 CHKPR(pointerEvent, ERROR_NULL_POINTER);
1327 PointerEvent::PointerItem item;
1328 item.SetPointerId(DEFAULT_POINTER_ID_FIRST);
1329 item.SetDisplayX(px1);
1330 item.SetDisplayY(py1);
1331 item.SetRawDisplayX(px1);
1332 item.SetRawDisplayY(py1);
1333 item.SetPressed(true);
1334 pointerEvent->SetPointerId(DEFAULT_POINTER_ID_FIRST);
1335 pointerEvent->AddPointerItem(item);
1336 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
1337 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
1338 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
1339 std::this_thread::sleep_for(std::chrono::milliseconds(intervalTimeMs));
1340
1341 item.SetPressed(false);
1342 item.SetDisplayY(py1);
1343 item.SetDisplayX(px1);
1344 item.SetRawDisplayY(py1);
1345 item.SetRawDisplayX(px1);
1346 pointerEvent->UpdatePointerItem(DEFAULT_POINTER_ID_FIRST, item);
1347 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
1348 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
1349 break;
1350 }
1351 case 'i': {
1352 int32_t takeTime = 0;
1353 if (!StrToInt(optarg, takeTime)) {
1354 std::cout << "invalid command to interval time" << std::endl;
1355 return EVENT_REG_FAIL;
1356 }
1357 const int64_t minTakeTimeMs = 1;
1358 const int64_t maxTakeTimeMs = 15000;
1359 if ((minTakeTimeMs > takeTime) || (maxTakeTimeMs < takeTime)) {
1360 std::cout << "takeTime is out of range. ";
1361 std::cout << minTakeTimeMs << " < takeTime < " << maxTakeTimeMs;
1362 std::cout << std::endl;
1363 return EVENT_REG_FAIL;
1364 }
1365 std::this_thread::sleep_for(std::chrono::milliseconds(takeTime));
1366 break;
1367 }
1368 case 'g': {
1369 const int32_t dragArgcSeven = 7;
1370 const int32_t dragArgcCommandNine = 9;
1371 if ((argc != dragArgcSeven) && (argc != dragArgcCommandNine)) {
1372 std::cout << "argc:" << argc << std::endl;
1373 std::cout << "wrong number of parameters" << std::endl;
1374 return RET_ERR;
1375 }
1376 totalTimeMs = TOTAL_TIME_MS;
1377 int32_t pressTimems = 500;
1378 if (argc == moveArgcSeven) {
1379 if ((!StrToInt(optarg, px1)) ||
1380 (!StrToInt(argv[optind], py1)) ||
1381 (!StrToInt(argv[optind + 1], px2)) ||
1382 (!StrToInt(argv[optind + 2], py2))) {
1383 std::cout << "invalid coordinate value" << std::endl;
1384 return RET_ERR;
1385 }
1386 } else {
1387 if ((!StrToInt(optarg, px1)) ||
1388 (!StrToInt(argv[optind], py1)) ||
1389 (!StrToInt(argv[optind + 1], px2)) ||
1390 (!StrToInt(argv[optind + 2], py2)) ||
1391 (!StrToInt(argv[optind + 3], pressTimems)) ||
1392 (!StrToInt(argv[optind + 4], totalTimeMs))) {
1393 std::cout << "invalid input coordinate or time" << std::endl;
1394 return RET_ERR;
1395 }
1396 }
1397 if ((px1 < 0) || (py1 < 0) || (px2 < 0) || (py2 < 0)) {
1398 std::cout << "Coordinate value must be greater or equal than 0" << std::endl;
1399 return RET_ERR;
1400 }
1401 const int32_t minTotalTimeMs = 1000;
1402 const int32_t maxTotalTimeMs = 15000;
1403 if ((minTotalTimeMs > totalTimeMs) || (maxTotalTimeMs < totalTimeMs)) {
1404 std::cout << "total time input is error" << std::endl;
1405 return RET_ERR;
1406 }
1407 const int32_t minPressTimeMs = 500;
1408 const int32_t maxPressTimeMs = 14500;
1409 if ((minPressTimeMs > pressTimems) || (maxPressTimeMs < pressTimems)) {
1410 std::cout << "press time is out of range" << std::endl;
1411 return RET_ERR;
1412 }
1413 const int32_t minMoveTimeMs = 500;
1414 if ((totalTimeMs - pressTimems) < minMoveTimeMs) {
1415 std::cout << "move time is out of range" << std::endl;
1416 return RET_ERR;
1417 }
1418 auto pointerEvent = PointerEvent::Create();
1419 CHKPR(pointerEvent, ERROR_NULL_POINTER);
1420 PointerEvent::PointerItem item;
1421 item.SetPointerId(DEFAULT_POINTER_ID_FIRST);
1422 item.SetDisplayY(py1);
1423 item.SetDisplayX(px1);
1424 item.SetRawDisplayY(py1);
1425 item.SetRawDisplayX(px1);
1426 pointerEvent->AddPointerItem(item);
1427 pointerEvent->SetPointerId(DEFAULT_POINTER_ID_FIRST);
1428 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
1429 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
1430 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
1431 const int32_t conversionRate = 1000;
1432 int64_t startTimeMs = GetSysClockTime() / conversionRate;
1433 int64_t endTimeMs = 0;
1434 if (!AddInt64(startTimeMs, totalTimeMs, endTimeMs)) {
1435 std::cout << "end time count error" << std::endl;
1436 return RET_ERR;
1437 }
1438 int64_t downTimeMs = 0;
1439 if (!AddInt64(startTimeMs, pressTimems, downTimeMs)) {
1440 std::cout << "down time count error" << std::endl;
1441 return RET_ERR;
1442 }
1443 int64_t currentTimeMs = startTimeMs;
1444 const int32_t moveTimeMs = totalTimeMs - pressTimems;
1445 while ((currentTimeMs < endTimeMs)) {
1446 if (currentTimeMs > downTimeMs) {
1447 item.SetDisplayX(NextPos(downTimeMs, currentTimeMs, moveTimeMs, px1, px2));
1448 item.SetDisplayY(NextPos(downTimeMs, currentTimeMs, moveTimeMs, py1, py2));
1449 item.SetRawDisplayX(NextPos(downTimeMs, currentTimeMs, moveTimeMs, px1, px2));
1450 item.SetRawDisplayY(NextPos(downTimeMs, currentTimeMs, moveTimeMs, py1, py2));
1451 pointerEvent->UpdatePointerItem(DEFAULT_POINTER_ID_FIRST, item);
1452 pointerEvent->SetActionTime(currentTimeMs * TIME_TRANSITION);
1453 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
1454 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
1455 }
1456 std::this_thread::sleep_for(std::chrono::milliseconds(BLOCK_TIME_MS));
1457 currentTimeMs = GetSysClockTime() / conversionRate;
1458 }
1459 item.SetDisplayX(px2);
1460 item.SetDisplayY(py2);
1461 item.SetRawDisplayX(px2);
1462 item.SetRawDisplayY(py2);
1463 pointerEvent->UpdatePointerItem(DEFAULT_POINTER_ID_FIRST, item);
1464 pointerEvent->SetActionTime(endTimeMs * TIME_TRANSITION);
1465 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
1466 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
1467 break;
1468 }
1469 case 'k': {
1470 if (firstOpt == 'S') {
1471 std::cout << "invalid argument k" << std::endl;
1472 return EVENT_REG_FAIL;
1473 }
1474 KnuckleGestureInputProcess(argc, argv, c, optionIndex);
1475 break;
1476 }
1477 default: {
1478 std::cout << "invalid command" << std::endl;
1479 ShowUsage();
1480 return EVENT_REG_FAIL;
1481 }
1482 }
1483 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEPTIME));
1484 }
1485 break;
1486 }
1487 case 'J': {
1488 JoystickInfo joyInfo;
1489 std::vector<std::pair<int32_t, JoystickInfo>> state;
1490 while ((c = getopt_long(argc, argv, "m:d:u:c:i:", joystickSensorOptions, &optionIndex)) != -1) {
1491 switch (c) {
1492 case 'm': {
1493 std::string arg(optarg);
1494 std::string::size_type pos = arg.find('=');
1495 if (pos == std::string::npos) {
1496 std::cout << "Parameter format is error" << std::endl;
1497 return EVENT_REG_FAIL;
1498 }
1499 std::string absAction = arg.substr(0, pos);
1500 if (absAction == "x") {
1501 joyInfo.absType = PointerEvent::AxisType::AXIS_TYPE_ABS_X;
1502 } else if (absAction == "y") {
1503 joyInfo.absType = PointerEvent::AxisType::AXIS_TYPE_ABS_Y;
1504 } else if (absAction == "z") {
1505 joyInfo.absType = PointerEvent::AxisType::AXIS_TYPE_ABS_Z;
1506 } else if (absAction == "rz") {
1507 joyInfo.absType = PointerEvent::AxisType::AXIS_TYPE_ABS_RZ;
1508 } else if (absAction == "gas") {
1509 joyInfo.absType = PointerEvent::AxisType::AXIS_TYPE_ABS_GAS;
1510 } else if (absAction == "brake") {
1511 joyInfo.absType = PointerEvent::AxisType::AXIS_TYPE_ABS_BRAKE;
1512 } else if (absAction == "hat0x") {
1513 joyInfo.absType = PointerEvent::AxisType::AXIS_TYPE_ABS_HAT0X;
1514 } else if (absAction == "hat0y") {
1515 joyInfo.absType = PointerEvent::AxisType::AXIS_TYPE_ABS_HAT0Y;
1516 } else if (absAction == "throttle") {
1517 joyInfo.absType = PointerEvent::AxisType::AXIS_TYPE_ABS_THROTTLE;
1518 } else {
1519 std::cout << "Invalid abstype" << std::endl;
1520 return RET_ERR;
1521 }
1522 if (!StrToInt(arg.substr(pos + 1), joyInfo.absValue)) {
1523 std::cout << "Invalid parameter to move absValue" << std::endl;
1524 return EVENT_REG_FAIL;
1525 }
1526 state.push_back(std::pair<int32_t, JoystickInfo>(JOYSTICK_MOVE, joyInfo));
1527 break;
1528 }
1529 case 'd': {
1530 if (!StrToInt(optarg, joyInfo.buttonId)) {
1531 std::cout << "Invalid button press command" << std::endl;
1532 return EVENT_REG_FAIL;
1533 }
1534 if (joyInfo.buttonId > JOYSTICK_BUTTON_ID) {
1535 std::cout << "Pressed button value is greater than the max value" << std::endl;
1536 return EVENT_REG_FAIL;
1537 }
1538 state.push_back(std::pair<int32_t, JoystickInfo>(JOYSTICK_BUTTON_PRESS, joyInfo));
1539 break;
1540 }
1541 case 'u': {
1542 if (!StrToInt(optarg, joyInfo.buttonId)) {
1543 std::cout << "Invalid raise button command" << std::endl;
1544 return EVENT_REG_FAIL;
1545 }
1546 if (joyInfo.buttonId > JOYSTICK_BUTTON_ID) {
1547 std::cout << "Raise button value is greater than the max value" << std::endl;
1548 return EVENT_REG_FAIL;
1549 }
1550 state.push_back(std::pair<int32_t, JoystickInfo>(JOYSTICK_BUTTON_UP, joyInfo));
1551 break;
1552 }
1553 case 'c': {
1554 if (!StrToInt(optarg, joyInfo.buttonId)) {
1555 std::cout << "Invalid click button command" << std::endl;
1556 return EVENT_REG_FAIL;
1557 }
1558 if (joyInfo.buttonId > JOYSTICK_BUTTON_ID) {
1559 std::cout << "Click button value is greater than the max value" << std::endl;
1560 return EVENT_REG_FAIL;
1561 }
1562 state.push_back(std::pair<int32_t, JoystickInfo>(JOYSTICK_CLICK, joyInfo));
1563 break;
1564 }
1565 case 'i': {
1566 if (!StrToInt(optarg, joyInfo.taktTime)) {
1567 std::cout << "Invalid command to interval time" << std::endl;
1568 return EVENT_REG_FAIL;
1569 }
1570 state.push_back(std::pair<int32_t, JoystickInfo>(JOYSTICK_INTERVAL, joyInfo));
1571 break;
1572 }
1573 default: {
1574 std::cout << "Invalid options" << std::endl;
1575 ShowUsage();
1576 return EVENT_REG_FAIL;
1577 }
1578 }
1579 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEPTIME));
1580 }
1581 auto pointerEvent = PointerEvent::Create();
1582 if (pointerEvent != nullptr) {
1583 if (optind < argc) {
1584 std::cout << "non-option argv elements: ";
1585 while (optind < argc) {
1586 std::cout << argv[optind++] << "\t";
1587 }
1588 std::cout << std::endl;
1589 return EVENT_REG_FAIL;
1590 }
1591 if (state.empty()) {
1592 std::cout << "Injection failed" << std::endl;
1593 return EVENT_REG_FAIL;
1594 }
1595 for (const auto &it : state) {
1596 if (it.first == JOYSTICK_BUTTON_PRESS) {
1597 std::cout << "Press down " << it.second.buttonId <<std::endl;
1598 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_BUTTON_DOWN);
1599 pointerEvent->SetButtonId(it.second.buttonId);
1600 pointerEvent->SetButtonPressed(it.second.buttonId);
1601 } else if (it.first == JOYSTICK_BUTTON_UP) {
1602 std::cout << "Lift up button " << it.second.buttonId << std::endl;
1603 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_BUTTON_UP);
1604 pointerEvent->SetButtonPressed(it.second.buttonId);
1605 pointerEvent->SetButtonId(it.second.buttonId);
1606 } else if (it.first == JOYSTICK_MOVE) {
1607 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_AXIS_UPDATE);
1608 pointerEvent->SetAxisValue(it.second.absType, it.second.absValue);
1609 } else if (it.first == JOYSTICK_CLICK) {
1610 std::cout << "Click " << it.second.buttonId << std::endl;
1611 pointerEvent->SetButtonId(it.second.buttonId);
1612 pointerEvent->SetPointerId(0);
1613 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_BUTTON_DOWN);
1614 pointerEvent->SetButtonPressed(it.second.buttonId);
1615 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_JOYSTICK);
1616 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
1617
1618 pointerEvent->SetButtonPressed(it.second.buttonId);
1619 pointerEvent->SetButtonId(it.second.buttonId);
1620 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_BUTTON_UP);
1621 } else if (it.first == JOYSTICK_INTERVAL) {
1622 if ((MIN_TAKTTIME_MS > joyInfo.taktTime) || (MAX_TAKTTIME_MS < joyInfo.taktTime)) {
1623 std::cout << "TaktTime is out of range" << std::endl;
1624 return EVENT_REG_FAIL;
1625 }
1626 std::this_thread::sleep_for(std::chrono::milliseconds(joyInfo.taktTime));
1627 continue;
1628 }
1629 pointerEvent->SetPointerId(0);
1630 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_JOYSTICK);
1631 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
1632 }
1633 }
1634 break;
1635 }
1636 case 'P': {
1637 int32_t ret = ProcessTouchPadGestureInput(argc, argv, optionIndex);
1638 if (ret != ERR_OK) {
1639 return ret;
1640 }
1641 break;
1642 }
1643 case '?': {
1644 ShowUsage();
1645 return ERR_OK;
1646 }
1647 default: {
1648 std::cout << "invalid command" << std::endl;
1649 ShowUsage();
1650 return EVENT_REG_FAIL;
1651 }
1652 }
1653 } else {
1654 std::cout << "too few arguments to function" << std::endl;
1655 ShowUsage();
1656 return EVENT_REG_FAIL;
1657 }
1658 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEPTIME));
1659 return ERR_OK;
1660 }
1661
1662 struct SpecialChar {
1663 int32_t keyCode = 0;
1664 bool isPressShift = false;
1665 };
1666
1667 const std::map<char, SpecialChar> CHAR_TO_KEYCODE = {
1668 { ' ', { KeyEvent::KEYCODE_SPACE, false} },
1669 { '!', { KeyEvent::KEYCODE_1, true} },
1670 { '\"', { KeyEvent::KEYCODE_APOSTROPHE, true} },
1671 { '#', { KeyEvent::KEYCODE_3, true} },
1672 { '$', { KeyEvent::KEYCODE_4, true} },
1673 { '%', { KeyEvent::KEYCODE_5, true} },
1674 { '&', { KeyEvent::KEYCODE_7, true} },
1675 { '\'', { KeyEvent::KEYCODE_APOSTROPHE, false} },
1676 { '(', { KeyEvent::KEYCODE_9, true} },
1677 { ')', { KeyEvent::KEYCODE_0, true} },
1678 { '*', { KeyEvent::KEYCODE_8, true} },
1679 { '+', { KeyEvent::KEYCODE_EQUALS, true} },
1680 { ',', { KeyEvent::KEYCODE_COMMA, false} },
1681 { '-', { KeyEvent::KEYCODE_MINUS, false} },
1682 { '.', { KeyEvent::KEYCODE_PERIOD, false} },
1683 { '/', { KeyEvent::KEYCODE_SLASH, false} },
1684 { ':', { KeyEvent::KEYCODE_SEMICOLON, true} },
1685 { ';', { KeyEvent::KEYCODE_SEMICOLON, false} },
1686 { '<', { KeyEvent::KEYCODE_COMMA, true} },
1687 { '=', { KeyEvent::KEYCODE_EQUALS, false} },
1688 { '>', { KeyEvent::KEYCODE_PERIOD, true} },
1689 { '?', { KeyEvent::KEYCODE_SLASH, true} },
1690 { '@', { KeyEvent::KEYCODE_2, true} },
1691 { '[', { KeyEvent::KEYCODE_LEFT_BRACKET, false} },
1692 { '\\', { KeyEvent::KEYCODE_BACKSLASH, false} },
1693 { ']', { KeyEvent::KEYCODE_RIGHT_BRACKET, false} },
1694 { '^', { KeyEvent::KEYCODE_6, true} },
1695 { '_', { KeyEvent::KEYCODE_MINUS, true} },
1696 { '`', { KeyEvent::KEYCODE_GRAVE, false} },
1697 { '{', { KeyEvent::KEYCODE_LEFT_BRACKET, true} },
1698 { '|', { KeyEvent::KEYCODE_BACKSLASH, true} },
1699 { '}', { KeyEvent::KEYCODE_RIGHT_BRACKET, true} },
1700 { '~', { KeyEvent::KEYCODE_GRAVE, true} },
1701 };
1702
IsSpecialChar(char character, int32_t &keyCode, bool &isPressShift)1703 bool InputManagerCommand::IsSpecialChar(char character, int32_t &keyCode, bool &isPressShift)
1704 {
1705 CALL_DEBUG_ENTER;
1706 auto iter = CHAR_TO_KEYCODE.find(character);
1707 if (iter == CHAR_TO_KEYCODE.end()) {
1708 return false;
1709 }
1710 keyCode = iter->second.keyCode;
1711 isPressShift = iter->second.isPressShift;
1712 return true;
1713 }
1714
PrintKeyboardTextChar(int32_t keyCode, bool isPressShift)1715 int32_t InputManagerCommand::PrintKeyboardTextChar(int32_t keyCode, bool isPressShift)
1716 {
1717 auto keyEvent = KeyEvent::Create();
1718 if (keyEvent == nullptr) {
1719 std::cout << "Failed to create input event object" << std::endl;
1720 return RET_ERR;
1721 }
1722 KeyEvent::KeyItem item;
1723
1724 if (isPressShift) {
1725 keyEvent->SetKeyCode(KeyEvent::KEYCODE_SHIFT_LEFT);
1726 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN);
1727 item.SetKeyCode(KeyEvent::KEYCODE_SHIFT_LEFT);
1728 item.SetPressed(true);
1729 keyEvent->AddKeyItem(item);
1730 InputManager::GetInstance()->SimulateInputEvent(keyEvent);
1731 }
1732
1733 keyEvent->SetKeyCode(keyCode);
1734 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN);
1735 item.SetKeyCode(keyCode);
1736 item.SetPressed(true);
1737 keyEvent->AddKeyItem(item);
1738 InputManager::GetInstance()->SimulateInputEvent(keyEvent);
1739
1740 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEPTIME));
1741
1742 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_UP);
1743 item.SetPressed(false);
1744 keyEvent->AddKeyItem(item);
1745 InputManager::GetInstance()->SimulateInputEvent(keyEvent);
1746
1747 if (isPressShift) {
1748 keyEvent->SetKeyCode(KeyEvent::KEYCODE_SHIFT_LEFT);
1749 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_UP);
1750 item.SetKeyCode(KeyEvent::KEYCODE_SHIFT_LEFT);
1751 item.SetPressed(false);
1752 keyEvent->AddKeyItem(item);
1753 InputManager::GetInstance()->SimulateInputEvent(keyEvent);
1754 }
1755 return RET_OK;
1756 }
1757
ProcessKeyboardTextInput(char *optarg, int32_t count)1758 int32_t InputManagerCommand::ProcessKeyboardTextInput(char *optarg, int32_t count)
1759 {
1760 if (count != 0) { // Prompt when combining the text command after using other commands. Ex: "uinput -t text -t text"
1761 std::cout << "The text command cannot be used with other commands." << std::endl;
1762 return RET_ERR;
1763 }
1764 constexpr int32_t textMaxLen = 2000; // 2000: max number of ascii characters
1765
1766 int32_t len = strlen(optarg);
1767 if (len <= 0) {
1768 std::cout << "The input is empty." << std::endl;
1769 return RET_ERR;
1770 } else if (len > textMaxLen) {
1771 std::cout << "The input text length is "<< len;
1772 std::cout << ", and it is processed according to the maximum processing length of ";
1773 std::cout << textMaxLen << " bytes." << std::endl;
1774 len = textMaxLen;
1775 }
1776
1777 char textChar = optarg[0];
1778 bool isPressShift = false;
1779 int32_t keyCode = -1;
1780 for (int32_t i = 0; i < len; ++i) {
1781 textChar = optarg[i];
1782 if ((textChar >= '0') && (textChar <= '9')) {
1783 isPressShift = false;
1784 keyCode = textChar - '0' + KeyEvent::KEYCODE_0;
1785 } else if ((textChar >= 'a') && (textChar <= 'z')) {
1786 isPressShift = false;
1787 keyCode = textChar - 'a' + KeyEvent::KEYCODE_A;
1788 } else if ((textChar >= 'A') && (textChar <= 'Z')) {
1789 isPressShift = true;
1790 keyCode = textChar - 'A' + KeyEvent::KEYCODE_A;
1791 } else if (!IsSpecialChar(textChar, keyCode, isPressShift)) {
1792 std::cout << "The character of index "<< i << " is invalid." << std::endl;
1793 return RET_ERR;
1794 }
1795
1796 if (PrintKeyboardTextChar(keyCode, isPressShift) == RET_ERR) {
1797 return RET_ERR;
1798 }
1799 }
1800 return RET_OK;
1801 }
1802
KnuckleGestureInputProcess(int32_t argc, char *argv[], int32_t c, int32_t optionIndex)1803 int32_t InputManagerCommand::KnuckleGestureInputProcess(int32_t argc, char *argv[], int32_t c, int32_t optionIndex)
1804 {
1805 struct option knuckleGestureSensorOptions[] = {
1806 {"single_finger_double_click", required_argument, nullptr, 's'},
1807 {"double_finger_double_click", required_argument, nullptr, 'd'},
1808 {nullptr, 0, nullptr, 0}
1809 };
1810
1811 while ((c = getopt_long(argc, argv, "s:d:", knuckleGestureSensorOptions, &optionIndex)) != -1) {
1812 switch (c) {
1813 case 's': {
1814 SingleKnuckleGestureProcesser(argc, argv);
1815 break;
1816 }
1817 case 'd': {
1818 DoubleKnuckleGestureProcesser(argc, argv);
1819 break;
1820 }
1821 default: {
1822 std::cout << "invalid command" << std::endl;
1823 ShowUsage();
1824 return EVENT_REG_FAIL;
1825 }
1826 }
1827 }
1828 return ERR_OK;
1829 }
1830
SingleKnuckleGestureProcesser(int32_t argc, char *argv[])1831 int32_t InputManagerCommand::SingleKnuckleGestureProcesser(int32_t argc, char *argv[])
1832 {
1833 int32_t knuckleUinputArgc = 8;
1834 int32_t intervalTimeMs = 0;
1835 int32_t firstDownX = 0;
1836 int32_t firstDownY = 0;
1837 int32_t secondDownX = 0;
1838 int32_t secondDownY = 0;
1839 if (optind < 0 || optind > argc) {
1840 std::cout << "wrong optind pointer index" << std::endl;
1841 return EVENT_REG_FAIL;
1842 }
1843 if (argc == knuckleUinputArgc) {
1844 if ((!StrToInt(optarg, firstDownX)) || !StrToInt(argv[optind], firstDownY) ||
1845 !StrToInt(argv[optind + 1], secondDownX) || !StrToInt(argv[optind + TWO_MORE_COMMAND], secondDownY)) {
1846 std::cout << "invalid coordinate value" << std::endl;
1847 return EVENT_REG_FAIL;
1848 }
1849 intervalTimeMs = DEFAULT_DELAY;
1850 } else if (argc == KNUCKLE_PARAM_SIZE) {
1851 if ((!StrToInt(optarg, firstDownX)) || !StrToInt(argv[optind], firstDownY) ||
1852 !StrToInt(argv[optind + 1], secondDownX) || !StrToInt(argv[optind + TWO_MORE_COMMAND], secondDownY) ||
1853 !StrToInt(argv[optind + THREE_MORE_COMMAND], intervalTimeMs)) {
1854 std::cout << "input coordinate or time error" << std::endl;
1855 return RET_ERR;
1856 }
1857 const int64_t minIntervalTimeMs = 1;
1858 const int64_t maxIntervalTimeMs = 250;
1859 if ((minIntervalTimeMs > intervalTimeMs) || (maxIntervalTimeMs < intervalTimeMs)) {
1860 std::cout << "interval time is out of range: " << minIntervalTimeMs << "ms";
1861 std::cout << " < interval time < " << maxIntervalTimeMs << "ms" << std::endl;
1862 return RET_ERR;
1863 }
1864 } else {
1865 std::cout << "wrong number of parameters:" << argc << std::endl;
1866 return EVENT_REG_FAIL;
1867 }
1868 if (IsCoordinateInvalid(firstDownX, firstDownY, secondDownX, secondDownY)) {
1869 std::cout << "Coordinate value must be greater or equal than 0" << std::endl;
1870 return RET_ERR;
1871 }
1872 std::cout << "single knuckle first down coordinate: ("<< firstDownX << ", " << firstDownY << ")" << std::endl;
1873 std::cout << "single knuckle second down coordinate: ("<< secondDownX << ", " << secondDownY << ")" << std::endl;
1874 std::cout << "single knuckle interval time: " << intervalTimeMs << "ms" << std::endl;
1875 SingleKnuckleClickEvent(firstDownX, firstDownY);
1876 std::this_thread::sleep_for(std::chrono::milliseconds(intervalTimeMs));
1877 SingleKnuckleClickEvent(secondDownX, secondDownY);
1878 return ERR_OK;
1879 }
1880
DoubleKnuckleGestureProcesser(int32_t argc, char *argv[])1881 int32_t InputManagerCommand::DoubleKnuckleGestureProcesser(int32_t argc, char *argv[])
1882 {
1883 int32_t knuckleUinputArgc = 8;
1884 int32_t intervalTimeMs = 0;
1885 int32_t firstDownX = 0;
1886 int32_t firstDownY = 0;
1887 int32_t secondDownX = 0;
1888 int32_t secondDownY = 0;
1889 if (optind < 0 || optind > argc) {
1890 std::cout << "wrong optind pointer index" << std::endl;
1891 return EVENT_REG_FAIL;
1892 }
1893 if (argc == knuckleUinputArgc) {
1894 if (!StrToInt(optarg, firstDownX) || !StrToInt(argv[optind], firstDownY) ||
1895 !StrToInt(argv[optind + 1], secondDownX) || !StrToInt(argv[optind + TWO_MORE_COMMAND], secondDownY)) {
1896 std::cout << "invalid coordinate value" << std::endl;
1897 return EVENT_REG_FAIL;
1898 }
1899 intervalTimeMs = DEFAULT_DELAY;
1900 } else if (argc == KNUCKLE_PARAM_SIZE) {
1901 if ((!StrToInt(optarg, firstDownX)) || !StrToInt(argv[optind], firstDownY) ||
1902 !StrToInt(argv[optind + 1], secondDownX) || !StrToInt(argv[optind + TWO_MORE_COMMAND], secondDownY) ||
1903 !StrToInt(argv[optind + THREE_MORE_COMMAND], intervalTimeMs)) {
1904 std::cout << "input coordinate or time error" << std::endl;
1905 return RET_ERR;
1906 }
1907 const int64_t minIntervalTimeMs = 1;
1908 const int64_t maxIntervalTimeMs = 250;
1909 if ((minIntervalTimeMs > intervalTimeMs) || (maxIntervalTimeMs < intervalTimeMs)) {
1910 std::cout << "interval time is out of range: " << minIntervalTimeMs << "ms";
1911 std::cout << " < interval time < " << maxIntervalTimeMs << "ms" << std::endl;
1912 return RET_ERR;
1913 }
1914 } else {
1915 std::cout << "wrong number of parameters: " << argc << std::endl;
1916 return EVENT_REG_FAIL;
1917 }
1918 if (IsCoordinateInvalid(firstDownX, firstDownY, secondDownX, secondDownY)) {
1919 std::cout << "Coordinate value must be greater or equal than 0" << std::endl;
1920 return RET_ERR;
1921 }
1922 std::cout << "double knukle first click coordinate: ("<< firstDownX << ", " << firstDownY << ")" << std::endl;
1923 std::cout << "double knukle second click coordinate: ("<< secondDownX << ", " << secondDownY << ")" << std::endl;
1924 std::cout << "double knuckle interval time: " << intervalTimeMs << "ms" << std::endl;
1925
1926 DoubleKnuckleClickEvent(firstDownX, firstDownY);
1927 std::this_thread::sleep_for(std::chrono::milliseconds(intervalTimeMs));
1928 DoubleKnuckleClickEvent(secondDownX, secondDownY);
1929 return ERR_OK;
1930 }
1931
IsCoordinateInvalid(int32_t firstDownX, int32_t firstDownY, int32_t secondDownX, int32_t secondDownY)1932 bool InputManagerCommand::IsCoordinateInvalid(int32_t firstDownX, int32_t firstDownY, int32_t secondDownX,
1933 int32_t secondDownY)
1934 {
1935 return firstDownX < 0 || firstDownY < 0 || secondDownX < 0 || secondDownY < 0;
1936 }
1937
SingleKnuckleClickEvent(int32_t downX, int32_t downY)1938 int32_t InputManagerCommand::SingleKnuckleClickEvent(int32_t downX, int32_t downY)
1939 {
1940 auto pointerEvent = PointerEvent::Create();
1941 CHKPR(pointerEvent, ERROR_NULL_POINTER);
1942 PointerEvent::PointerItem item;
1943 item.SetPointerId(0);
1944 item.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE);
1945 item.SetDisplayX(downX);
1946 item.SetDisplayY(downY);
1947 item.SetRawDisplayX(downX);
1948 item.SetRawDisplayY(downY);
1949 item.SetPressed(true);
1950 pointerEvent->SetPointerId(0);
1951 pointerEvent->AddPointerItem(item);
1952 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
1953 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
1954 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
1955
1956 item.SetPressed(false);
1957 item.SetDisplayY(downY);
1958 item.SetDisplayX(downX);
1959 item.SetRawDisplayY(downY);
1960 item.SetRawDisplayX(downX);
1961 item.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE);
1962 pointerEvent->UpdatePointerItem(0, item);
1963 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
1964 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
1965 return ERR_OK;
1966 }
1967
DoubleKnuckleClickEvent(int32_t downX, int32_t downY)1968 int32_t InputManagerCommand::DoubleKnuckleClickEvent(int32_t downX, int32_t downY)
1969 {
1970 auto pointerEvent = PointerEvent::Create();
1971 CHKPR(pointerEvent, ERROR_NULL_POINTER);
1972 PointerEvent::PointerItem item;
1973 PointerEvent::PointerItem item2;
1974 item.SetPointerId(0);
1975 item.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE);
1976 item.SetDisplayX(downX);
1977 item.SetDisplayY(downY);
1978 item.SetRawDisplayX(downX);
1979 item.SetRawDisplayY(downY);
1980 item.SetPressed(true);
1981 pointerEvent->SetPointerId(0);
1982 pointerEvent->AddPointerItem(item);
1983
1984 item2.SetPointerId(1);
1985 item2.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE);
1986 item2.SetDisplayX(downX);
1987 item2.SetDisplayY(downY);
1988 item2.SetRawDisplayX(downX);
1989 item2.SetRawDisplayY(downY);
1990 item2.SetPressed(true);
1991 pointerEvent->SetPointerId(1);
1992 pointerEvent->AddPointerItem(item2);
1993 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
1994 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
1995 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
1996
1997 item.SetPressed(false);
1998 item.SetDisplayY(downY);
1999 item.SetDisplayX(downX);
2000 item.SetRawDisplayY(downY);
2001 item.SetRawDisplayX(downX);
2002 item.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE);
2003 item2.SetPressed(false);
2004 item2.SetDisplayY(downY);
2005 item2.SetDisplayX(downX);
2006 item2.SetRawDisplayY(downY);
2007 item2.SetRawDisplayX(downX);
2008 item2.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE);
2009 pointerEvent->UpdatePointerItem(0, item);
2010 pointerEvent->UpdatePointerItem(1, item2);
2011 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
2012 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
2013 return ERR_OK;
2014 }
2015
ProcessTouchPadGestureInput(int32_t argc, char *argv[], int32_t optionIndex)2016 int32_t InputManagerCommand::ProcessTouchPadGestureInput(int32_t argc, char *argv[], int32_t optionIndex)
2017 {
2018 struct option touchPadSensorOptions[] = {
2019 {"rotate", required_argument, nullptr, 'r'},
2020 {"swipe", required_argument, nullptr, 's'},
2021 {"pinch", required_argument, nullptr, 'p'},
2022 {nullptr, 0, nullptr, 0}
2023 };
2024 int32_t opt = 0;
2025 if ((opt = getopt_long(argc, argv, "r:s:p:", touchPadSensorOptions, &optionIndex)) != -1) {
2026 switch (opt) {
2027 case 'r': {
2028 int32_t ret = ProcessRotateGesture(argc, argv);
2029 if (ret != ERR_OK) {
2030 return ret;
2031 }
2032 break;
2033 }
2034 case 's': {
2035 int32_t ret = ProcessTouchPadFingerSwipe(argc, argv);
2036 if (ret != ERR_OK) {
2037 return ret;
2038 }
2039 break;
2040 }
2041 case 'p': {
2042 // uinput -P -p <finger count> <scale percent numerator> e.g. uinput -P -p 2 200
2043 int32_t ret = ProcessPinchGesture(argc, argv);
2044 if (ret != ERR_OK) {
2045 return ret;
2046 }
2047 break;
2048 }
2049 default: {
2050 std::cout << "invalid command" << std::endl;
2051 ShowUsage();
2052 return EVENT_REG_FAIL;
2053 }
2054 }
2055 }
2056 return ERR_OK;
2057 }
2058
ProcessRotateGesture(int32_t argc, char *argv[])2059 int32_t InputManagerCommand::ProcessRotateGesture(int32_t argc, char *argv[])
2060 {
2061 auto pointerEvent = PointerEvent::Create();
2062 CHKPR(pointerEvent, ERROR_NULL_POINTER);
2063 int32_t rotateValue = 0;
2064 constexpr int32_t paramNum = 4;
2065 constexpr int32_t conversionValue = 360;
2066 if (argc == paramNum) {
2067 if (!StrToInt(optarg, rotateValue)) {
2068 std::cout << "Invalid angle data" << std::endl;
2069 return RET_ERR;
2070 }
2071 if ((rotateValue >= conversionValue) || (rotateValue <= -(conversionValue))) {
2072 std::cout << "Rotate value must be within (-360,360)" << std::endl;
2073 return RET_ERR;
2074 }
2075 std::cout << "Input rotate value:"<<rotateValue << std::endl;
2076 pointerEvent->SetAxisValue(PointerEvent::AXIS_TYPE_ROTATE, rotateValue);
2077 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_ROTATE_END);
2078 pointerEvent->SetPointerId(0);
2079 PointerEvent::PointerItem item;
2080 item.SetPointerId(0);
2081 pointerEvent->AddPointerItem(item);
2082 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHPAD);
2083 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
2084 } else {
2085 std::cout << "Invalid angle data,Input parameter example: uinput - P - r 45" << std::endl;
2086 return RET_ERR;
2087 }
2088 return ERR_OK;
2089 }
2090
ProcessPinchGesture(int32_t argc, char *argv[])2091 int32_t InputManagerCommand::ProcessPinchGesture(int32_t argc, char *argv[])
2092 {
2093 CHKPR(argv, ERROR_NULL_POINTER);
2094 constexpr int32_t actionInputArgc = 6;
2095 constexpr int32_t minScaleNumerator = 0;
2096 constexpr int32_t maxScaleNumerator = 500;
2097 constexpr int32_t hundred = 100;
2098 constexpr int32_t fingerCount = 2;
2099 int32_t centerX = 0;
2100 int32_t centerY = 0;
2101 int32_t scalePercentNumerator = 0;
2102 std::string tips = "uinput -P -p dx, dy, scalePercent; dx, dy, scalePercent are all number.";
2103 std::string extralTips = " dx is bigger than 0 and dy is bigger than 200. 0 < scalePercent < 500;";
2104 if (optind < 0 || optind > argc) {
2105 std::cout << "wrong optind pointer index" << std::endl;
2106 std::cout << tips << extralTips << std::endl;
2107 return RET_ERR;
2108 }
2109 int32_t startPos = optind - MOVE_POS_ONE;
2110 if (argc == actionInputArgc) {
2111 if ((!StrToInt(argv[startPos], centerX)) ||
2112 (!StrToInt(argv[startPos + MOVE_POS_ONE], centerY)) ||
2113 (!StrToInt(argv[startPos + MOVE_POS_TWO], scalePercentNumerator))) {
2114 std::cout << tips << extralTips << std::endl;
2115 return RET_ERR;
2116 }
2117 } else {
2118 std::cout << tips << extralTips << std::endl;
2119 return RET_ERR;
2120 }
2121 if ((scalePercentNumerator <= minScaleNumerator) || (scalePercentNumerator > maxScaleNumerator)) {
2122 std::cout << "Invalid scale numberator:" << scalePercentNumerator << std::endl;
2123 std::cout << tips << extralTips << std::endl;
2124 return RET_ERR;
2125 }
2126 bool check = (centerX > 0) && (centerY >= hundred * fingerCount);
2127 if (!check) {
2128 std::cout << tips << extralTips << std::endl;
2129 return RET_ERR;
2130 }
2131 return ActionPinchEvent(centerX, centerY, scalePercentNumerator);
2132 }
2133
SwipeActionEvent(int32_t startX, int32_t startY, int32_t endX, int32_t endY)2134 int32_t InputManagerCommand::SwipeActionEvent(int32_t startX, int32_t startY, int32_t endX, int32_t endY)
2135 {
2136 constexpr int32_t fingerCount = 3;
2137 constexpr int32_t times = 10;
2138 constexpr int32_t thousand = 1000;
2139 int32_t disY = static_cast<int32_t>(static_cast<double>(endY - startY) / times);
2140 int32_t disX = static_cast<int32_t>(static_cast<double>(endX - startX) / times);
2141 int32_t actionType[10] = {PointerEvent::POINTER_ACTION_SWIPE_BEGIN};
2142 int64_t actionTimeBase = GetSysClockTime() - times * thousand * thousand;
2143 int64_t actionTimeStartTimeDis = fingerCount * thousand;
2144 int64_t actionStartTime[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
2145 int64_t actionTime[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
2146 int32_t sourceType = PointerEvent::SOURCE_TYPE_TOUCHPAD;
2147 actionTime[0] = actionTimeBase;
2148 actionStartTime[0] = (actionTimeBase - actionTimeStartTimeDis) / thousand;
2149 for (int32_t i = 1; i < times; i++) {
2150 actionStartTime[i] = actionStartTime[i - 1] + times - fingerCount;
2151 actionTime[i] = actionTime[i - 1] + times - fingerCount;
2152 actionType[i] = PointerEvent::POINTER_ACTION_SWIPE_UPDATE;
2153 }
2154 actionType[times - 1] = PointerEvent::POINTER_ACTION_SWIPE_END;
2155 for (int32_t i = 0; i < times; i++) {
2156 auto pointerEvent = CreateEvent(0, actionType[i], fingerCount - 1, sourceType, fingerCount);
2157 CHKPR(pointerEvent, ERROR_NULL_POINTER);
2158 pointerEvent->SetActionTime(actionTime[i]);
2159 pointerEvent->SetActionStartTime(actionStartTime[i]);
2160 PointerEvent::PointerItem item;
2161 item.SetDownTime(pointerEvent->GetActionStartTime());
2162 item.SetDisplayX(startX + disX * i);
2163 item.SetDisplayY(startY + disY * i);
2164 item.SetPointerId(0);
2165 pointerEvent->SetSourceType(sourceType);
2166 pointerEvent->AddPointerItem(item);
2167 pointerEvent->AddPointerItem(item);
2168 std::this_thread::sleep_for(std::chrono::microseconds(SLEEPTIME));
2169 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
2170 }
2171 return ERR_OK;
2172 }
2173
ProcessTouchPadFingerSwipe(int32_t argc, char *argv[])2174 int32_t InputManagerCommand::ProcessTouchPadFingerSwipe(int32_t argc, char *argv[])
2175 {
2176 constexpr int32_t actionInputArgc = 7;
2177 int32_t startX = 0;
2178 int32_t startY = 0;
2179 int32_t endX = 0;
2180 int32_t endY = 0;
2181 if (optind < 0 || optind > argc) {
2182 std::cout << "wrong optind pointer index" << std::endl;
2183 return RET_ERR;
2184 }
2185 int32_t startPos = optind - MOVE_POS_ONE;
2186 std::string tip = "uinput -P -s startX, startY, endX, endY;";
2187 std::string extralTip = "And startX, startY, endX, endY are all number which is bigger than 0;";
2188 if (argc == actionInputArgc) {
2189 if ((!StrToInt(argv[startPos], startX)) ||
2190 (!StrToInt(argv[startPos + MOVE_POS_ONE], startY)) ||
2191 (!StrToInt(argv[startPos + MOVE_POS_TWO], endX)) ||
2192 (!StrToInt(argv[startPos + MOVE_POS_THREE], endY))) {
2193 std::cout << tip << extralTip << std::endl;
2194 return RET_ERR;
2195 }
2196 } else {
2197 std::cout << tip << extralTip << std::endl;
2198 return RET_ERR;
2199 }
2200 bool check = (startX > 0) && (endX > 0) && (startY > 0) && (endY > 0);
2201 if (!check) {
2202 std::cout << tip << extralTip << std::endl;
2203 return RET_ERR;
2204 }
2205 return SwipeActionEvent(startX, startY, endX, endY);
2206 }
2207
CreateEvent( int32_t id, int32_t type, int32_t pointerId, int32_t sourceType, int32_t fingerCount)2208 std::shared_ptr<PointerEvent> InputManagerCommand::CreateEvent(
2209 int32_t id,
2210 int32_t type,
2211 int32_t pointerId,
2212 int32_t sourceType,
2213 int32_t fingerCount)
2214 {
2215 auto pointerEvent = PointerEvent::Create();
2216 CHKPP(pointerEvent);
2217 pointerEvent->SetId(id);
2218 pointerEvent->SetOriginPointerAction(type);
2219 pointerEvent->SetPointerAction(type);
2220 pointerEvent->SetPointerId(pointerId);
2221 pointerEvent->SetSourceType(sourceType);
2222 pointerEvent->SetFingerCount(fingerCount);
2223 return pointerEvent;
2224 }
2225
FillPointerItem( PointerEvent::PointerItem &item, int32_t pointX, int32_t pointY, int32_t id, bool press)2226 void InputManagerCommand::FillPointerItem(
2227 PointerEvent::PointerItem &item,
2228 int32_t pointX,
2229 int32_t pointY,
2230 int32_t id,
2231 bool press)
2232 {
2233 item.SetDisplayX(pointX);
2234 item.SetDisplayY(pointY);
2235 item.SetWindowX(pointX);
2236 item.SetWindowY(pointY);
2237 item.SetPointerId(id);
2238 item.SetPressed(press);
2239 }
2240
ActionPinchEvent(int32_t centerX, int32_t centerY, int32_t scalePercentNumerator)2241 int32_t InputManagerCommand::ActionPinchEvent(int32_t centerX, int32_t centerY, int32_t scalePercentNumerator)
2242 {
2243 CALL_DEBUG_ENTER;
2244 constexpr int32_t hundred = 100;
2245 constexpr int32_t fingerCount = 2;
2246 constexpr int32_t idSecondItem = 1;
2247 int32_t timesForSleep = hundred * hundred;
2248 int32_t distance = 0;
2249 int32_t times = hundred / (fingerCount * fingerCount * fingerCount);
2250 int32_t topX = centerX;
2251 int32_t bottomX = centerX;
2252 int32_t stepY = 0;
2253 int32_t actionType = PointerEvent::POINTER_ACTION_AXIS_BEGIN;
2254 double scalePinch = 1.0;
2255 if (scalePercentNumerator > hundred) {
2256 distance = hundred / fingerCount;
2257 stepY = 0 - (distance / (fingerCount * times));
2258 } else {
2259 distance = hundred * fingerCount;
2260 stepY = distance / (fingerCount * times);
2261 }
2262 int32_t topY = centerY - distance;
2263 int32_t bottomY = centerY + distance;
2264 double scalePinchChange = ((static_cast<double>(scalePercentNumerator) / hundred) - 1) / (times - 1);
2265 SendTouchDownForPinch(topX, topY, bottomX, bottomY);
2266 for (int32_t index = 0; index < times; index++) {
2267 if (index != 0) {
2268 actionType = PointerEvent::POINTER_ACTION_AXIS_UPDATE;
2269 scalePinch = scalePinch + scalePinchChange;
2270 }
2271 auto pointerEvent = CreateEvent(0, actionType, 0, PointerEvent::SOURCE_TYPE_TOUCHPAD, fingerCount);
2272 CHKPR(pointerEvent, ERROR_NULL_POINTER);
2273 pointerEvent->SetAxisValue(PointerEvent::AXIS_TYPE_PINCH, scalePinch);
2274 PointerEvent::PointerItem itemFirst;
2275 topY = topY + stepY;
2276 bottomY = bottomY - stepY;
2277 FillPointerItem(itemFirst, topX, topY, 0, false);
2278 itemFirst.SetToolType(PointerEvent::TOOL_TYPE_TOUCHPAD);
2279 itemFirst.SetDownTime(pointerEvent->GetActionStartTime());
2280 pointerEvent->AddPointerItem(itemFirst);
2281 PointerEvent::PointerItem itemSecond;
2282 FillPointerItem(itemSecond, bottomX, bottomY, idSecondItem, true);
2283 pointerEvent->SetPointerId(idSecondItem);
2284 pointerEvent->AddPointerItem(itemSecond);
2285 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
2286 std::this_thread::sleep_for(std::chrono::microseconds(SLEEPTIME * timesForSleep));
2287 }
2288 return RET_OK;
2289 }
2290
SendTouchDownForPinch(int32_t topX, int32_t topY, int32_t bottomX, int32_t bottomY)2291 void InputManagerCommand::SendTouchDownForPinch(int32_t topX, int32_t topY, int32_t bottomX, int32_t bottomY)
2292 {
2293 constexpr int32_t fingerCount = 2;
2294 int32_t itemId = 0;
2295 auto pointerEvent = CreateEvent(0, PointerEvent::POINTER_ACTION_DOWN, 0,
2296 PointerEvent::SOURCE_TYPE_TOUCHPAD, fingerCount);
2297 CHKPV(pointerEvent);
2298 pointerEvent->SetPointerId(itemId);
2299 PointerEvent::PointerItem itemFirst;
2300 FillPointerItem(itemFirst, topX, topY, itemId, true);
2301 itemFirst.SetToolType(PointerEvent::TOOL_TYPE_MOUSE);
2302 pointerEvent->AddPointerItem(itemFirst);
2303 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
2304 std::this_thread::sleep_for(std::chrono::microseconds(SLEEPTIME));
2305 pointerEvent = CreateEvent(0, PointerEvent::POINTER_ACTION_DOWN, 0,
2306 PointerEvent::SOURCE_TYPE_TOUCHPAD, fingerCount);
2307 CHKPV(pointerEvent);
2308 itemId = itemId + 1;
2309 pointerEvent->SetPointerId(itemId);
2310 PointerEvent::PointerItem itemSecond;
2311 FillPointerItem(itemSecond, bottomX, bottomY, itemId, true);
2312 pointerEvent->AddPointerItem(itemFirst);
2313 pointerEvent->AddPointerItem(itemSecond);
2314 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
2315 }
2316
PrintMouseUsage()2317 void InputManagerCommand::PrintMouseUsage()
2318 {
2319 std::cout << "-m <dx> <dy> --move <dx> <dy> -move to relative position (dx,dy)," << std::endl;
2320 std::cout << " <dx1> <dy1> <dx2> <dy2> [smooth time] --trace -dx1 dy1 to dx2 dy2 smooth movement" << std::endl;
2321 std::cout << "-d <key> --down key -press down a button, " << std::endl;
2322 std::cout << " 0 is the left button, 1 is the right," << std::endl;
2323 std::cout << " 2 is the middle" << std::endl;
2324 std::cout << "-u <key> --up <key> -release a button " << std::endl;
2325 std::cout << "-c <key> --click <key> -press the left button down,then raise" << std::endl;
2326 std::cout << "-b <dx1> <dy1> <id> [press time] [click interval time] --double click" << std::endl;
2327 std::cout << " [press time] the time range is more than 1ms but less than 300ms, " << std::endl;
2328 std::cout << " [click interval time] the time range is more than 1ms but less than 450ms, " << std::endl;
2329 std::cout << " Otherwise the operation result may produce error or invalid operation" << std::endl;
2330 std::cout << " -press the left button down,then raise" << std::endl;
2331 std::cout << " key value:0 - button left" << std::endl;
2332 std::cout << " key value:1 - button right" << std::endl;
2333 std::cout << " key value:2 - button middle" << std::endl;
2334 std::cout << " key value:3 - button side" << std::endl;
2335 std::cout << " key value:4 - button extra" << std::endl;
2336 std::cout << " key value:5 - button forward" << std::endl;
2337 std::cout << " key value:6 - button back" << std::endl;
2338 std::cout << " key value:7 - button task" << std::endl;
2339 std::cout << "-s <key> --scroll <key> -positive values are sliding backwards" << std::endl;
2340 std::cout << "-g <dx1> <dy1> <dx2> <dy2> [total time] --drag <dx1> <dy1> <dx2> <dy2> [total time],";
2341 std::cout << std::endl;
2342 std::cout << " dx1 dy1 to dx2 dy2 smooth drag" << std::endl;
2343 std::cout << "-i <time> --interval <time> -the program interval for the (time) milliseconds";
2344 std::cout << std::endl;
2345 std::cout << " negative values are sliding forwards" << std::endl;
2346 }
2347
PrintKeyboardUsage()2348 void InputManagerCommand::PrintKeyboardUsage()
2349 {
2350 std::cout << "-d <key> --down <key> -press down a key" << std::endl;
2351 std::cout << "-u <key> --up <key> -release a key " << std::endl;
2352 std::cout << "-l <key> [long press time] --long_press <key> [long press time] -press and hold the key";
2353 std::cout << std::endl;
2354 std::cout << "-r <key> [repeat output time] --repeat output <key> [repeat output time] -press and hold the key";
2355 std::cout << std::endl;
2356 std::cout << "-i <time> --interval <time> -the program interval for the (time) milliseconds";
2357 std::cout << std::endl;
2358 std::cout << "-t <text> --text <text> -input text content. ";
2359 std::cout << "The text command cannot be used with other commands." << std::endl;
2360 }
2361
PrintStylusUsage()2362 void InputManagerCommand::PrintStylusUsage()
2363 {
2364 std::cout << "-d <dx1> <dy1> --down <dx1> <dy1> -press down a position dx1 dy1, " << std::endl;
2365 std::cout << "-u <dx1> <dy1> --up <dx1> <dy1> -release a position dx1 dy1, " << std::endl;
2366 std::cout << "-i <time> --interval <time> -the program interval for the (time) milliseconds";
2367 std::cout << std::endl;
2368 std::cout << "-m <dx1> <dy1> <dx2> <dy2> [smooth time] --smooth movement" << std::endl;
2369 std::cout << " <dx1> <dy1> <dx2> <dy2> [smooth time] -smooth movement, " << std::endl;
2370 std::cout << " dx1 dy1 to dx2 dy2 smooth movement" << std::endl;
2371 std::cout << "-c <dx1> <dy1> [click interval] -touch screen click dx1 dy1" << std::endl;
2372 std::cout << "-g <dx1> <dy1> <dx2> <dy2> [press time] [total time] -drag, " << std::endl;
2373 std::cout << " [Press time] not less than 500ms and [total time] - [Press time] not less than 500ms" << std::endl;
2374 std::cout << " Otherwise the operation result may produce error or invalid operation" << std::endl;
2375 }
2376
PrintTouchUsage()2377 void InputManagerCommand::PrintTouchUsage()
2378 {
2379 std::cout << "-d <dx1> <dy1> --down <dx1> <dy1> -press down a position dx1 dy1, " << std::endl;
2380 std::cout << "-u <dx1> <dy1> --up <dx1> <dy1> -release a position dx1 dy1, " << std::endl;
2381 std::cout << "-i <time> --interval <time> -the program interval for the (time) milliseconds";
2382 std::cout << std::endl;
2383 std::cout << "-m <dx1> <dy1> <dx2> <dy2> [-k keep time] [smooth time] --smooth movement, keep time:keep time";
2384 std::cout << std::endl;
2385 std::cout << " after moving, the max value is 60000 ";
2386 std::cout << std::endl;
2387 std::cout << " ms, default value is 0; smooth time:";
2388 std::cout << std::endl;
2389 std::cout << " move time, default value is 1000 ms,";
2390 std::cout << std::endl;
2391 std::cout << " the max value is 15000 ms";
2392 std::cout << std::endl;
2393 std::cout << " Supports up to three finger movement at the same time, for example:" << std::endl;
2394 std::cout << " uinput -T -m 300 900 600 900 900 900 600 900, (300, 900) move to (600, 900), (900, 900) move to";
2395 std::cout << std::endl;
2396 std::cout << " (600, 900)" << std::endl;
2397 std::cout << "-c <dx1> <dy1> [click interval] -touch screen click dx1 dy1" << std::endl;
2398 std::cout << "-k --knuckle " << std::endl;
2399 std::cout << "commands for knucle: " << std::endl;
2400 PrintKnuckleUsage();
2401 std::cout << std::endl;
2402 std::cout << "-g <dx1> <dy1> <dx2> <dy2> [press time] [total time] -drag, " << std::endl;
2403 std::cout << " [Press time] not less than 500ms and [total time] - [Press time] not less than 500ms" << std::endl;
2404 std::cout << " Otherwise the operation result may produce error or invalid operation" << std::endl;
2405 }
2406
PrintKnuckleUsage()2407 void InputManagerCommand::PrintKnuckleUsage()
2408 {
2409 std::cout << "-s <dx1> <dy1> <dx2> <dy2> [interval time] --single knuckle double click interval time" << std::endl;
2410 std::cout << "-d <dx1> <dy1> <dx2> <dy2> [interval time] --double knuckle double click interval time" << std::endl;
2411 std::cout << "-i <time> --interval <time> -the program interval for the (time) milliseconds";
2412 }
2413
PrintTouchPadUsage()2414 void InputManagerCommand::PrintTouchPadUsage()
2415 {
2416 std::cout << "-p dx, dy, scalePercent; dx, dy, scalePercent are all number." << std::endl;
2417 std::cout << "dx is bigger than 0 and dy is bigger than 200. 0 < scalePercent < 500;" << std::endl;
2418 std::cout << "While simulate this, make sure that a picture is on the top of the desktop." << std::endl;
2419 std::cout << "-s startX, startY, endX, endY;" << std::endl;
2420 std::cout << "And startX, startY, endX, endY are all number which is bigger than 0;" << std::endl;
2421 std::cout << "While simulate this, make sure that your actual action is available" << std::endl;
2422 std::cout << "-r <rotate value> rotate value must be within (-360,360)" << std::endl;
2423 }
2424
ShowUsage()2425 void InputManagerCommand::ShowUsage()
2426 {
2427 std::cout << "Usage: uinput <option> <command> <arg>..." << std::endl;
2428 std::cout << "The option are: " << std::endl;
2429 std::cout << "-K --keyboard " << std::endl;
2430 std::cout << "commands for keyboard: " << std::endl;
2431 PrintKeyboardUsage();
2432 std::cout << std::endl;
2433
2434 std::cout << "-M --mouse " << std::endl;
2435 std::cout << "commands for mouse: " << std::endl;
2436 PrintMouseUsage();
2437 std::cout << std::endl;
2438
2439 std::cout << "-P --touchpad " << std::endl;
2440 std::cout << "commands for touchpad: " << std::endl;
2441 PrintTouchPadUsage();
2442
2443 std::cout << "-S --stylus " << std::endl;
2444 std::cout << "commands for stylus: " << std::endl;
2445 PrintStylusUsage();
2446 std::cout << std::endl;
2447
2448 std::cout << "-T --touch " << std::endl;
2449 std::cout << "commands for touch: " << std::endl;
2450 PrintTouchUsage();
2451 std::cout << std::endl;
2452
2453 std::cout << " " << std::endl;
2454 std::cout << "-? --help " << std::endl;
2455 }
2456 } // namespace MMI
2457 } // namespace OHOS