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