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