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