1 /* 2 * Copyright (c) 2025 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 "key_subscriber_handler.h" 17 18 #include <fstream> 19 #include <list> 20 21 #include <gtest/gtest.h> 22 23 #ifdef OHOS_BUILD_ENABLE_CALL_MANAGER 24 #include "call_manager_client.h" 25 #endif // OHOS_BUILD_ENABLE_CALL_MANAGER 26 27 #include "want.h" 28 29 #include "common_event_data.h" 30 #include "common_event_manager.h" 31 #include "common_event_support.h" 32 #include "device_event_monitor.h" 33 #include "display_event_monitor.h" 34 #include "event_log_helper.h" 35 #include "input_event_handler.h" 36 #include "key_event.h" 37 #include "key_option.h" 38 #include "key_shortcut_manager.h" 39 #include "mmi_log.h" 40 #include "nap_process.h" 41 #include "switch_subscriber_handler.h" 42 #include "tablet_subscriber_handler.h" 43 #include "uds_server.h" 44 45 #undef MMI_LOG_TAG 46 #define MMI_LOG_TAG "KeyCommandHandlerTest" 47 48 namespace OHOS { 49 namespace MMI { 50 namespace { 51 using namespace testing::ext; 52 const std::string PROGRAM_NAME = "uds_session_test"; 53 constexpr int32_t MODULE_TYPE { 1 }; 54 constexpr int32_t UDS_FD { 1 }； 55 constexpr int32_t UDS_UID { 100 }; 56 constexpr int32_t UDS_PID { 100 }; 57 constexpr int32_t REMOVE_OBSERVER { -2 }; 58 constexpr int32_t UNOBSERVED { -1 }; 59 constexpr int32_t ACTIVE_EVENT { 2 }; 60 constexpr uint32_t MAX_PRE_KEY_COUNT { 4 }; 61 } // namespace 62 63 class KeySubscriberHandlerTest : public testing::Test { 64 public: SetUpTestCase(void)65 static void SetUpTestCase(void) {} TearDownTestCase(void)66 static void TearDownTestCase(void) {} 67 }; 68 69 /** 70 * @tc.name: KeySubscriberHandlerTest_HandleKeyEvent_001 71 * @tc.desc: Test HandleKeyEvent 72 * @tc.type: FUNC 73 * @tc.require: 74 */ 75 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleKeyEvent_001, TestSize.Level1) 76 { 77 CALL_DEBUG_ENTER; 78 KeySubscriberHandler handler; 79 KeyEvent::KeyItem item; 80 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 81 ASSERT_NE(keyEvent, nullptr); 82 handler.enableCombineKey_ = false; 83 keyEvent->SetKeyCode(KeyEvent::KEYCODE_BRIGHTNESS_DOWN); 84 item.SetKeyCode(KeyEvent::KEYCODE_A); 85 keyEvent->AddKeyItem(item); 86 item.SetKeyCode(KeyEvent::KEYCODE_B); 87 keyEvent->AddKeyItem(item); 88 EXPECT_FALSE(handler.OnSubscribeKeyEvent(keyEvent)); 89 ASSERT_NO_FATAL_FAILURE(handler.HandleKeyEvent(keyEvent)); 90 91 handler.enableCombineKey_ = true; 92 handler.hasEventExecuting_ = true; 93 handler.keyEvent_ = KeyEvent::Create(); 94 ASSERT_NE(handler.keyEvent_, nullptr); 95 handler.keyEvent_->SetKeyCode(KeyEvent::KEYCODE_BRIGHTNESS_DOWN); 96 handler.keyEvent_->SetKeyAction(KeyEvent::KEY_ACTION_UP); 97 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_UP); 98 item.SetKeyCode(KeyEvent::KEYCODE_A); 99 handler.keyEvent_->AddKeyItem(item); 100 item.SetKeyCode(KeyEvent::KEYCODE_B); 101 handler.keyEvent_->AddKeyItem(item); 102 EXPECT_TRUE(handler.OnSubscribeKeyEvent(keyEvent)); 103 EXPECT_TRUE(EventLogHelper::IsBetaVersion()); 104 EXPECT_FALSE(keyEvent->HasFlag(InputEvent::EVENT_FLAG_PRIVACY_MODE)); 105 ASSERT_NO_FATAL_FAILURE(handler.HandleKeyEvent(keyEvent)); 106 } 107 108 /** 109 * @tc.name: KeySubscriberHandlerTest_DumpSubscriber_001 110 * @tc.desc: Test DumpSubscriber 111 * @tc.type: FUNC 112 * @tc.require: 113 */ 114 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_DumpSubscriber_001, TestSize.Level1) 115 { 116 CALL_TEST_DEBUG; 117 KeySubscriberHandler handler; 118 int32_t fd = 1; 119 SessionPtr sess; 120 auto keyOption = std::make_shared<KeyOption>(); 121 keyOption->preKeys_.insert(10); 122 keyOption->preKeys_.insert(20); 123 keyOption->preKeys_.insert(30); 124 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 125 ASSERT_NO_FATAL_FAILURE(handler.DumpSubscriber(fd, subscriber)); 126 } 127 128 /** 129 * @tc.name: InputWindowsManagerTest_UnsubscribeKeyEvent_001 130 * @tc.desc: Test UnsubscribeKeyEvent 131 * @tc.type: FUNC 132 * @tc.require: 133 */ 134 HWTEST_F(KeySubscriberHandlerTest, InputWindowsManagerTest_UnsubscribeKeyEvent_001, TestSize.Level1) 135 { 136 CALL_TEST_DEBUG; 137 KeySubscriberHandler keySubscriberHandler; 138 auto keyEvent = KeyEvent::Create(); 139 ASSERT_NE(keyEvent, nullptr); 140 keySubscriberHandler.HandleKeyEvent(keyEvent); 141 auto pointerEvent = PointerEvent::Create(); 142 keySubscriberHandler.HandlePointerEvent(pointerEvent); 143 keySubscriberHandler.HandleTouchEvent(pointerEvent); 144 keySubscriberHandler.RemoveSubscriberKeyUpTimer(1); 145 std::vector<std::string> args = {}; 146 keySubscriberHandler.Dump(1, args); 147 UDSServer udsServer; 148 SessionPtr sess = udsServer.GetSessionByPid(1); 149 std::shared_ptr<KeyOption> keyOption = nullptr; 150 ASSERT_EQ(keySubscriberHandler.SubscribeKeyEvent(sess, -1, keyOption), -1); 151 SessionPtr sessPtr = nullptr; 152 ASSERT_NE(keySubscriberHandler.UnsubscribeKeyEvent(sessPtr, -1), 0); 153 ASSERT_NE(keySubscriberHandler.UnsubscribeKeyEvent(sess, 1), 0); 154 } 155 156 /** 157 * @tc.name: KeySubscriberHandlerTest_IsEnableCombineKey_001 158 * @tc.desc: Test IsEnableCombineKey 159 * @tc.type: FUNC 160 * @tc.require: 161 */ 162 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsEnableCombineKey_001, TestSize.Level1) 163 { 164 CALL_TEST_DEBUG; 165 KeySubscriberHandler keySubscriberHandler; 166 keySubscriberHandler.EnableCombineKey(false); 167 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 168 CHKPV(keyEvent); 169 KeyEvent::KeyItem item; 170 item.SetKeyCode(KeyEvent::KEYCODE_POWER); 171 keyEvent->AddKeyItem(item); 172 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 173 keySubscriberHandler.HandleKeyEvent(keyEvent); 174 ASSERT_EQ(keySubscriberHandler.EnableCombineKey(true), RET_OK); 175 } 176 177 /** 178 * @tc.name: KeySubscriberHandlerTest_IsEnableCombineKey_002 179 * @tc.desc: Test IsEnableCombineKey 180 * @tc.type: FUNC 181 * @tc.require: 182 */ 183 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsEnableCombineKey_002, TestSize.Level1) 184 { 185 CALL_TEST_DEBUG; 186 KeySubscriberHandler keySubscriberHandler; 187 keySubscriberHandler.EnableCombineKey(false); 188 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 189 CHKPV(keyEvent); 190 KeyEvent::KeyItem item1; 191 item1.SetKeyCode(KeyEvent::KEYCODE_META_LEFT); 192 keyEvent->AddKeyItem(item1); 193 KeyEvent::KeyItem item2; 194 item2.SetKeyCode(KeyEvent::KEYCODE_L); 195 keyEvent->AddKeyItem(item2); 196 keyEvent->SetKeyCode(KeyEvent::KEYCODE_L); 197 ASSERT_EQ(keySubscriberHandler.EnableCombineKey(true), RET_OK); 198 } 199 200 /** 201 * @tc.name: KeySubscriberHandlerTest_EnableCombineKey_001 202 * @tc.desc: Test enable combineKey 203 * @tc.type: FUNC 204 * @tc.require: 205 */ 206 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_EnableCombineKey_001, TestSize.Level1) 207 { 208 CALL_TEST_DEBUG; 209 KeySubscriberHandler keySubscriberHandler; 210 ASSERT_EQ(keySubscriberHandler.EnableCombineKey(true), RET_OK); 211 } 212 213 /** 214 * @tc.name: KeySubscriberHandlerTest_SubscribeKeyEvent_001 215 * @tc.desc: Test subscribe keyEvent 216 * @tc.type: FUNC 217 * @tc.require: 218 */ 219 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_SubscribeKeyEvent_001, TestSize.Level1) 220 { 221 CALL_DEBUG_ENTER; 222 KeySubscriberHandler handler; 223 SessionPtr sess; 224 auto keyOption = std::make_shared<KeyOption>(); 225 int32_t ret = handler.SubscribeKeyEvent(sess, -1, keyOption); 226 ASSERT_EQ(ret, RET_ERR); 227 ret = handler.SubscribeKeyEvent(nullptr, 1, keyOption); 228 ASSERT_NE(ret, RET_OK); 229 ret = handler.SubscribeKeyEvent(sess, 1, keyOption); 230 ASSERT_NE(ret, RET_OK); 231 } 232 233 /** 234 * @tc.name: KeySubscriberHandlerTest_RemoveSubscriber_001 235 * @tc.desc: Test remove subscriber 236 * @tc.type: FUNC 237 * @tc.require: 238 */ 239 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_RemoveSubscriber_001, TestSize.Level1) 240 { 241 CALL_DEBUG_ENTER; 242 KeySubscriberHandler handler; 243 SessionPtr sess; 244 int32_t ret = handler.RemoveSubscriber(sess, 1, true); 245 ASSERT_EQ(ret, RET_ERR); 246 ret = handler.RemoveSubscriber(nullptr, 1, true); 247 ASSERT_EQ(ret, RET_ERR); 248 } 249 250 /** 251 * @tc.name: KeySubscriberHandlerTest_IsEqualKeyOption_001 252 * @tc.desc: Test is equal keyOption 253 * @tc.type: FUNC 254 * @tc.require: 255 */ 256 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsEqualKeyOption_001, TestSize.Level1) 257 { 258 CALL_DEBUG_ENTER; 259 KeySubscriberHandler handler; 260 auto newOption = std::make_shared<KeyOption>(); 261 auto oldOption = std::make_shared<KeyOption>(); 262 newOption->SetPreKeys({1, 2, 3}); 263 oldOption->SetPreKeys({4, 5, 6}); 264 ASSERT_FALSE(handler.IsEqualKeyOption(newOption, oldOption)); 265 newOption->SetFinalKey(1); 266 oldOption->SetFinalKey(2); 267 ASSERT_FALSE(handler.IsEqualKeyOption(newOption, oldOption)); 268 newOption->SetFinalKeyDown(true); 269 oldOption->SetFinalKeyDown(false); 270 ASSERT_FALSE(handler.IsEqualKeyOption(newOption, oldOption)); 271 newOption->SetFinalKeyDownDuration(100); 272 oldOption->SetFinalKeyDownDuration(200); 273 ASSERT_FALSE(handler.IsEqualKeyOption(newOption, oldOption)); 274 newOption->SetFinalKeyUpDelay(100); 275 oldOption->SetFinalKeyUpDelay(200); 276 ASSERT_FALSE(handler.IsEqualKeyOption(newOption, oldOption)); 277 newOption->SetPreKeys({1, 2, 3}); 278 oldOption->SetPreKeys({1, 2, 3}); 279 newOption->SetFinalKey(1); 280 oldOption->SetFinalKey(1); 281 newOption->SetFinalKeyDown(true); 282 oldOption->SetFinalKeyDown(true); 283 newOption->SetFinalKeyDownDuration(100); 284 oldOption->SetFinalKeyDownDuration(100); 285 newOption->SetFinalKeyUpDelay(100); 286 oldOption->SetFinalKeyUpDelay(100); 287 ASSERT_TRUE(handler.IsEqualKeyOption(newOption, oldOption)); 288 } 289 290 /** 291 * @tc.name: KeySubscriberHandlerTest_IsPreKeysMatch_001 292 * @tc.desc: Test is preKeys match 293 * @tc.type: FUNC 294 * @tc.require: 295 */ 296 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsPreKeysMatch_001, TestSize.Level1) 297 { 298 CALL_DEBUG_ENTER; 299 KeySubscriberHandler handler; 300 std::set<int32_t> preKeys; 301 std::vector<int32_t> pressedKeys = {1, 2, 3}; 302 ASSERT_TRUE(handler.IsPreKeysMatch(preKeys, pressedKeys)); 303 preKeys = {1, 2, 3}; 304 ASSERT_TRUE(handler.IsPreKeysMatch(preKeys, pressedKeys)); 305 pressedKeys = {1, 2, 3, 4}; 306 ASSERT_FALSE(handler.IsPreKeysMatch(preKeys, pressedKeys)); 307 pressedKeys = {1, 2, 3}; 308 preKeys = {1, 2, 3, 4}; 309 ASSERT_FALSE(handler.IsPreKeysMatch(preKeys, pressedKeys)); 310 } 311 312 /** 313 * @tc.name: KeySubscriberHandlerTest_IsEqualPreKeys_001 314 * @tc.desc: Test is equal preKeys 315 * @tc.type: FUNC 316 * @tc.require: 317 */ 318 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsEqualPreKeys_001, TestSize.Level1) 319 { 320 CALL_TEST_DEBUG; 321 KeySubscriberHandler handler; 322 std::set<int32_t> preKeys = {1, 2, 3}; 323 std::set<int32_t> pressedKeys = {4, 5, 6}; 324 ASSERT_FALSE(handler.IsEqualPreKeys(preKeys, pressedKeys)); 325 pressedKeys = {1, 2, 3}; 326 ASSERT_TRUE(handler.IsEqualPreKeys(preKeys, pressedKeys)); 327 pressedKeys = {1, 2}; 328 ASSERT_FALSE(handler.IsEqualPreKeys(preKeys, pressedKeys)); 329 } 330 331 /** 332 * @tc.name: KeySubscriberHandlerTest_IsMatchForegroundPid_001 333 * @tc.desc: Test is match foreground pid 334 * @tc.type: FUNC 335 * @tc.require: 336 */ 337 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsMatchForegroundPid_001, TestSize.Level1) 338 { 339 CALL_TEST_DEBUG; 340 KeySubscriberHandler handler; 341 std::list<std::shared_ptr<OHOS::MMI::KeySubscriberHandler::Subscriber>> subs; 342 std::set<int32_t> foregroundPids = {1, 2, 3}; 343 ASSERT_FALSE(handler.IsMatchForegroundPid(subs, foregroundPids)); 344 } 345 346 /** 347 * @tc.name: KeySubscriberHandlerTest_NotifyKeyDownSubscriber_001 348 * @tc.desc: Test notify key down subscriber 349 * @tc.type: FUNC 350 * @tc.require: 351 */ 352 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifyKeyDownSubscriber_001, TestSize.Level1) 353 { 354 CALL_TEST_DEBUG; 355 KeySubscriberHandler handler; 356 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 357 auto keyOption = std::make_shared<KeyOption>(); 358 std::list<std::shared_ptr<OHOS::MMI::KeySubscriberHandler::Subscriber>> subscribers; 359 bool handled = false; 360 ASSERT_NO_FATAL_FAILURE(handler.NotifyKeyDownSubscriber(keyEvent, keyOption, subscribers, handled)); 361 keyEvent = nullptr; 362 ASSERT_NO_FATAL_FAILURE(handler.NotifyKeyDownSubscriber(keyEvent, keyOption, subscribers, handled)); 363 } 364 365 /** 366 * @tc.name: KeySubscriberHandlerTest_NotifyKeyDownRightNow_001 367 * @tc.desc: Test notify key down right now 368 * @tc.type: FUNC 369 * @tc.require: 370 */ 371 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifyKeyDownRightNow_001, TestSize.Level1) 372 { 373 CALL_TEST_DEBUG; 374 KeySubscriberHandler handler; 375 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 376 std::list<std::shared_ptr<OHOS::MMI::KeySubscriberHandler::Subscriber>> subscribers; 377 bool handled = false; 378 handler.NotifyKeyDownRightNow(keyEvent, subscribers, true, handled); 379 ASSERT_FALSE(handled); 380 } 381 382 /** 383 * @tc.name: KeySubscriberHandlerTest_NotifyKeyDownDelay_001 384 * @tc.desc: Test notify key down delay 385 * @tc.type: FUNC 386 * @tc.require: 387 */ 388 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifyKeyDownDelay_001, TestSize.Level1) 389 { 390 CALL_DEBUG_ENTER; 391 KeySubscriberHandler handler; 392 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 393 CHKPV(keyEvent); 394 KeyEvent::KeyItem item; 395 item.SetKeyCode(KeyEvent::KEYCODE_POWER); 396 keyEvent->AddKeyItem(item); 397 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 398 std::list<std::shared_ptr<OHOS::MMI::KeySubscriberHandler::Subscriber>> subscribers; 399 bool handled = false; 400 handler.NotifyKeyDownDelay(keyEvent, subscribers, handled); 401 ASSERT_FALSE(handled); 402 } 403 404 /** 405 * @tc.name: KeySubscriberHandlerTest_InitSessionDeleteCallback_001 406 * @tc.desc: Test init session delete callback 407 * @tc.type: FUNC 408 * @tc.require: 409 */ 410 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_InitSessionDeleteCallback_001, TestSize.Level1) 411 { 412 CALL_DEBUG_ENTER; 413 KeySubscriberHandler handler; 414 handler.callbackInitialized_ = true; 415 ASSERT_TRUE(handler.InitSessionDeleteCallback()); 416 handler.callbackInitialized_ = false; 417 ASSERT_FALSE(handler.InitSessionDeleteCallback()); 418 } 419 420 /** 421 * @tc.name: KeySubscriberHandlerTest_HandleKeyDown_001 422 * @tc.desc: Test handle key down 423 * @tc.type: FUNC 424 * @tc.require: 425 */ 426 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleKeyDown_001, TestSize.Level1) 427 { 428 CALL_DEBUG_ENTER; 429 KeySubscriberHandler handler; 430 auto result = handler.HandleKeyDown(nullptr); 431 ASSERT_FALSE(result); 432 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 433 CHKPV(keyEvent); 434 result = handler.HandleKeyDown(keyEvent); 435 ASSERT_FALSE(result); 436 } 437 438 /** 439 * @tc.name: KeySubscriberHandlerTest_RemoveKeyCode_001 440 * @tc.desc: Test remove key code 441 * @tc.type: FUNC 442 * @tc.require: 443 */ 444 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_RemoveKeyCode_001, TestSize.Level1) 445 { 446 CALL_TEST_DEBUG; 447 KeySubscriberHandler handler; 448 std::vector<int32_t> keyCodes; 449 handler.RemoveKeyCode(1, keyCodes); 450 ASSERT_TRUE(keyCodes.empty()); 451 keyCodes = {2, 3, 4}; 452 handler.RemoveKeyCode(1, keyCodes); 453 ASSERT_EQ(keyCodes, (std::vector<int32_t>{2, 3, 4})); 454 keyCodes = {1, 2, 3}; 455 ASSERT_EQ(keyCodes, (std::vector<int32_t>{1, 2, 3})); 456 } 457 458 /** 459 * @tc.name: KeySubscriberHandlerTest_AddSubscriber_001 460 * @tc.desc: Test add subscriber 461 * @tc.type: FUNC 462 * @tc.require: 463 */ 464 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_AddSubscriber_001, TestSize.Level1) 465 { 466 CALL_TEST_DEBUG; 467 KeySubscriberHandler handler; 468 SessionPtr sess; 469 std::shared_ptr<KeyOption> keyOption; 470 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 471 std::shared_ptr<KeyOption> option = std::make_shared<KeyOption>(); 472 handler.AddSubscriber(subscriber, option, true); 473 auto it = handler.subscriberMap_.find(option); 474 ASSERT_NE(it->second.front(), subscriber); 475 auto newSubscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 476 handler.AddSubscriber(newSubscriber, option, true); 477 ASSERT_NE(it->second.back(), newSubscriber); 478 } 479 480 /** 481 * @tc.name: KeySubscriberHandlerTest_IsFunctionKey_001 482 * @tc.desc: Test is function key 483 * @tc.type: FUNC 484 * @tc.require: 485 */ 486 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsFunctionKey_001, TestSize.Level1) 487 { 488 CALL_TEST_DEBUG; 489 KeySubscriberHandler handler; 490 auto keyEvent = std::make_shared<KeyEvent>(KeyEvent::KEYCODE_BRIGHTNESS_DOWN); 491 ASSERT_FALSE(handler.IsFunctionKey(keyEvent)); 492 keyEvent = std::make_shared<KeyEvent>(KeyEvent::KEYCODE_BRIGHTNESS_UP); 493 ASSERT_FALSE(handler.IsFunctionKey(keyEvent)); 494 keyEvent = std::make_shared<KeyEvent>(KeyEvent::KEYCODE_MUTE); 495 ASSERT_FALSE(handler.IsFunctionKey(keyEvent)); 496 keyEvent = std::make_shared<KeyEvent>(KeyEvent::KEYCODE_SWITCHVIDEOMODE); 497 ASSERT_FALSE(handler.IsFunctionKey(keyEvent)); 498 keyEvent = std::make_shared<KeyEvent>(KeyEvent::KEYCODE_WLAN); 499 ASSERT_FALSE(handler.IsFunctionKey(keyEvent)); 500 keyEvent = std::make_shared<KeyEvent>(KeyEvent::KEYCODE_CONFIG); 501 ASSERT_FALSE(handler.IsFunctionKey(keyEvent)); 502 keyEvent = std::make_shared<KeyEvent>(KeyEvent::KEYCODE_A); 503 ASSERT_FALSE(handler.IsFunctionKey(keyEvent)); 504 } 505 506 /** 507 * @tc.name: KeySubscriberHandlerTest_CloneKeyEvent_001 508 * @tc.desc: Test clone key event 509 * @tc.type: FUNC 510 * @tc.require: 511 */ 512 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_CloneKeyEvent_001, TestSize.Level1) 513 { 514 CALL_TEST_DEBUG; 515 KeySubscriberHandler handler; 516 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 517 ASSERT_NE(keyEvent, nullptr); 518 ASSERT_TRUE(handler.CloneKeyEvent(keyEvent)); 519 handler.keyEvent_ = nullptr; 520 ASSERT_TRUE(handler.CloneKeyEvent(keyEvent)); 521 } 522 523 /** 524 * @tc.name: KeySubscriberHandlerTest_NotifyKeyUpSubscriber_001 525 * @tc.desc: Test notify key up subscriber 526 * @tc.type: FUNC 527 * @tc.require: 528 */ 529 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifyKeyUpSubscriber_001, TestSize.Level1) 530 { 531 CALL_TEST_DEBUG; 532 KeySubscriberHandler handler; 533 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 534 ASSERT_NE(keyEvent, nullptr); 535 std::list<std::shared_ptr<OHOS::MMI::KeySubscriberHandler::Subscriber>> subscribers; 536 bool handled = false; 537 handler.NotifyKeyUpSubscriber(keyEvent, subscribers, handled); 538 ASSERT_FALSE(handled); 539 handler.isForegroundExits_ = false; 540 handler.NotifyKeyUpSubscriber(keyEvent, subscribers, handled); 541 ASSERT_FALSE(handled); 542 handler.isForegroundExits_ = true; 543 handler.foregroundPids_.clear(); 544 handler.NotifyKeyUpSubscriber(keyEvent, subscribers, handled); 545 ASSERT_FALSE(handled); 546 } 547 548 /** 549 * @tc.name: KeySubscriberHandlerTest_IsEnableCombineKeySwipe_001 550 * @tc.desc: Test is enable combine key swipe 551 * @tc.type: FUNC 552 * @tc.require: 553 */ 554 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsEnableCombineKeySwipe_001, TestSize.Level1) 555 { 556 CALL_TEST_DEBUG; 557 KeySubscriberHandler handler; 558 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 559 ASSERT_NE(keyEvent, nullptr); 560 KeyEvent::KeyItem item; 561 item.SetKeyCode(KeyEvent::KEYCODE_CTRL_LEFT); 562 keyEvent->AddKeyItem(item); 563 keyEvent->SetKeyCode(KeyEvent::KEYCODE_CTRL_LEFT); 564 ASSERT_TRUE(handler.IsEnableCombineKeySwipe(keyEvent)); 565 item.SetKeyCode(KeyEvent::KEYCODE_META_LEFT); 566 keyEvent->AddKeyItem(item); 567 keyEvent->SetKeyCode(KeyEvent::KEYCODE_META_LEFT); 568 ASSERT_TRUE(handler.IsEnableCombineKeySwipe(keyEvent)); 569 item.SetKeyCode(KeyEvent::KEYCODE_DPAD_RIGHT); 570 keyEvent->AddKeyItem(item); 571 keyEvent->SetKeyCode(KeyEvent::KEYCODE_DPAD_RIGHT); 572 ASSERT_TRUE(handler.IsEnableCombineKeySwipe(keyEvent)); 573 item.SetKeyCode(KeyEvent::KEYCODE_CTRL_RIGHT); 574 keyEvent->AddKeyItem(item); 575 keyEvent->SetKeyCode(KeyEvent::KEYCODE_CTRL_RIGHT); 576 ASSERT_TRUE(handler.IsEnableCombineKeySwipe(keyEvent)); 577 item.SetKeyCode(KeyEvent::KEYCODE_A); 578 keyEvent->AddKeyItem(item); 579 keyEvent->SetKeyCode(KeyEvent::KEYCODE_A); 580 ASSERT_TRUE(handler.IsEnableCombineKeySwipe(keyEvent)); 581 } 582 583 /** 584 * @tc.name: KeySubscriberHandlerTest_OnSubscribeKeyEvent_001 585 * @tc.desc: Test on subscribe key event 586 * @tc.type: FUNC 587 * @tc.require: 588 */ 589 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_OnSubscribeKeyEvent_001, TestSize.Level1) 590 { 591 CALL_TEST_DEBUG; 592 KeySubscriberHandler handler; 593 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 594 ASSERT_NE(keyEvent, nullptr); 595 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 596 ASSERT_FALSE(handler.OnSubscribeKeyEvent(keyEvent)); 597 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_UP); 598 ASSERT_FALSE(handler.OnSubscribeKeyEvent(keyEvent)); 599 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_CANCEL); 600 ASSERT_FALSE(handler.OnSubscribeKeyEvent(keyEvent)); 601 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_CANCEL); 602 ASSERT_FALSE(handler.OnSubscribeKeyEvent(keyEvent)); 603 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 604 handler.OnSubscribeKeyEvent(keyEvent); 605 ASSERT_FALSE(handler.OnSubscribeKeyEvent(keyEvent)); 606 } 607 608 /** 609 * @tc.name: KeySubscriberHandlerTest_OnSessionDelete_001 610 * @tc.desc: Test onSession delete 611 * @tc.type: FUNC 612 * @tc.require: 613 */ 614 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_OnSessionDelete_001, TestSize.Level1) 615 { 616 CALL_TEST_DEBUG; 617 KeySubscriberHandler handler; 618 UDSServer udsServer; 619 auto keyOption = std::make_shared<KeyOption>(); 620 SessionPtr sess = udsServer.GetSessionByPid(1); 621 std::list<std::shared_ptr<OHOS::MMI::KeySubscriberHandler::Subscriber>>subscriberMap_; 622 auto newSubscriber1 = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 623 auto newSubscriber2 = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(2, sess, keyOption); 624 auto newSubscriber3 = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(3, sess, keyOption); 625 subscriberMap_.push_back(newSubscriber1); 626 subscriberMap_.push_back(newSubscriber2); 627 subscriberMap_.push_back(newSubscriber3); 628 handler.OnSessionDelete(sess); 629 for (auto& sub : subscriberMap_) { 630 ASSERT_EQ(sub->sess_, nullptr); 631 } 632 } 633 634 /** 635 * @tc.name: KeySubscriberHandlerTest_ClearSubscriberTimer_001 636 * @tc.desc: Test clear subscriber timer 637 * @tc.type: FUNC 638 * @tc.require: 639 */ 640 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_ClearSubscriberTimer_001, TestSize.Level1) 641 { 642 CALL_TEST_DEBUG; 643 KeySubscriberHandler handler; 644 SessionPtr sess; 645 std::shared_ptr<KeyOption> keyOption; 646 std::list<std::shared_ptr<OHOS::MMI::KeySubscriberHandler::Subscriber>> subscribers; 647 auto subscriber1 = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 648 auto subscriber2 = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(2, sess, keyOption); 649 subscribers.push_back(subscriber1); 650 subscribers.push_back(subscriber2); 651 ASSERT_NO_FATAL_FAILURE(handler.ClearSubscriberTimer(subscribers)); 652 } 653 654 /** 655 * @tc.name: KeySubscriberHandlerTest_OnTimer_001 656 * @tc.desc: Test OnTimer 657 * @tc.type: FUNC 658 * @tc.require: 659 */ 660 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_OnTimer_001, TestSize.Level1) 661 { 662 CALL_TEST_DEBUG; 663 KeySubscriberHandler handler; 664 SessionPtr sess; 665 std::shared_ptr<KeyOption> keyOption; 666 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 667 subscriber->keyEvent_.reset(); 668 handler.OnTimer(subscriber); 669 ASSERT_EQ(subscriber->keyEvent_, nullptr); 670 } 671 672 /** 673 * @tc.name: KeySubscriberHandlerTest_SubscriberNotifyNap_001 674 * @tc.desc: Test SubscriberNotifyNap 675 * @tc.type: FUNC 676 * @tc.require: 677 */ 678 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_SubscriberNotifyNap_001, TestSize.Level1) 679 { 680 CALL_TEST_DEBUG; 681 KeySubscriberHandler handler; 682 SessionPtr sess; 683 std::shared_ptr<KeyOption> keyOption; 684 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 685 ASSERT_NO_FATAL_FAILURE(handler.SubscriberNotifyNap(subscriber)); 686 } 687 688 /** 689 * @tc.name: KeySubscriberHandlerTest_HandleKeyUp_001 690 * @tc.desc: Test HandleKeyUp 691 * @tc.type: FUNC 692 * @tc.require: 693 */ 694 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleKeyUp_001, TestSize.Level1) 695 { 696 CALL_TEST_DEBUG; 697 KeySubscriberHandler handler; 698 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 699 ASSERT_NE(keyEvent, nullptr); 700 KeyEvent::KeyItem item; 701 item.SetKeyCode(KeyEvent::KEYCODE_POWER); 702 keyEvent->AddKeyItem(item); 703 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 704 bool handled = handler.HandleKeyUp(keyEvent); 705 EXPECT_FALSE(handled); 706 } 707 708 /** 709 * @tc.name: KeySubscriberHandlerTest_NotifySubscriber_001 710 * @tc.desc: Test NotifySubscriber 711 * @tc.type: FUNC 712 * @tc.require: 713 */ 714 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifySubscriber_001, TestSize.Level1) 715 { 716 CALL_TEST_DEBUG; 717 KeySubscriberHandler handler; 718 SessionPtr sess; 719 std::shared_ptr<KeyOption> keyOption; 720 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 721 ASSERT_NE(keyEvent, nullptr); 722 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 723 KeyEvent::KeyItem item; 724 item.SetKeyCode(KeyEvent::KEYCODE_POWER); 725 keyEvent->AddKeyItem(item); 726 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 727 ASSERT_NO_FATAL_FAILURE(handler.NotifySubscriber(keyEvent, subscriber)); 728 } 729 730 /** 731 * @tc.name: KeySubscriberHandlerTest_HandleKeyCancel_001 732 * @tc.desc: Test HandleKeyCancel 733 * @tc.type: FUNC 734 * @tc.require: 735 */ 736 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleKeyCancel_001, TestSize.Level1) 737 { 738 CALL_TEST_DEBUG; 739 KeySubscriberHandler handler; 740 UDSServer udsServer; 741 SessionPtr sess = udsServer.GetSessionByPid(1); 742 auto keyOption = std::make_shared<KeyOption>(); 743 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 744 ASSERT_NE(keyEvent, nullptr); 745 std::list<std::shared_ptr<OHOS::MMI::KeySubscriberHandler::Subscriber>>subscriberMap_; 746 auto newSubscriber1 = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 747 auto newSubscriber2 = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(2, sess, keyOption); 748 subscriberMap_.push_back(newSubscriber1); 749 subscriberMap_.push_back(newSubscriber2); 750 EXPECT_FALSE(handler.HandleKeyCancel(keyEvent)); 751 } 752 753 /** 754 * @tc.name: KeySubscriberHandlerTest_PrintKeyOption_001 755 * @tc.desc: Test PrintKeyOption 756 * @tc.type: FUNC 757 * @tc.require: 758 */ 759 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_PrintKeyOption_001, TestSize.Level1) 760 { 761 CALL_TEST_DEBUG; 762 KeySubscriberHandler handler; 763 auto keyOption = std::make_shared<KeyOption>(); 764 keyOption->SetFinalKey(1); 765 keyOption->SetFinalKeyDown(true); 766 keyOption->SetFinalKeyDownDuration(1000); 767 keyOption->SetPreKeys({1, 2, 3}); 768 ASSERT_NO_FATAL_FAILURE(handler.PrintKeyOption(keyOption)); 769 } 770 771 #ifdef OHOS_BUILD_ENABLE_CALL_MANAGER 772 /** 773 * @tc.name: KeySubscriberHandlerTest_HandleKeyUpWithDelay_002 774 * @tc.desc: Test HandleKeyUpWithDelay 775 * @tc.type: FUNC 776 * @tc.require: 777 */ 778 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleKeyUpWithDelay_002, TestSize.Level1) 779 { 780 CALL_TEST_DEBUG; 781 KeySubscriberHandler handler; 782 SessionPtr sess; 783 auto keyOption = std::make_shared<KeyOption>(); 784 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 785 ASSERT_NE(keyEvent, nullptr); 786 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 787 788 subscriber->keyOption_->finalKeyUpDelay_ = -2; 789 ASSERT_NO_FATAL_FAILURE(handler.HandleKeyUpWithDelay(keyEvent, subscriber)); 790 } 791 792 /** 793 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_001 794 * @tc.desc: Test ring mute 795 * @tc.type: FUNC 796 * @tc.require: 797 */ 798 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_001, TestSize.Level1) 799 { 800 CALL_TEST_DEBUG; 801 KeySubscriberHandler keySubscriberHandler; 802 OHOS::EventFwk::Want want; 803 want.SetParam("state", StateType::CALL_STATUS_INCOMING); 804 OHOS::EventFwk::CommonEventData data; 805 data.SetWant(want); 806 int callState = 0; 807 DEVICE_MONITOR->SetCallState(data, callState); 808 809 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 810 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 811 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 812 } 813 814 /** 815 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_002 816 * @tc.desc: Test ring mute 817 * @tc.type: FUNC 818 * @tc.require: 819 */ 820 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_002, TestSize.Level1) 821 { 822 CALL_TEST_DEBUG; 823 KeySubscriberHandler keySubscriberHandler; 824 OHOS::EventFwk::Want want; 825 want.SetParam("state", StateType::CALL_STATUS_DISCONNECTED); 826 OHOS::EventFwk::CommonEventData data; 827 data.SetWant(want); 828 int callState = 0; 829 DEVICE_MONITOR->SetCallState(data, callState); 830 want.SetParam("state", StateType::CALL_STATUS_INCOMING); 831 data.SetWant(want); 832 callState = 0; 833 DEVICE_MONITOR->SetCallState(data, callState); 834 835 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 836 keyEvent->SetKeyCode(KeyEvent::KEYCODE_VOLUME_DOWN); 837 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 838 } 839 840 /** 841 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_003 842 * @tc.desc: Test ring mute 843 * @tc.type: FUNC 844 * @tc.require: 845 */ 846 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_003, TestSize.Level1) 847 { 848 CALL_TEST_DEBUG; 849 KeySubscriberHandler keySubscriberHandler; 850 OHOS::EventFwk::Want want; 851 want.SetParam("state", StateType::CALL_STATUS_DISCONNECTED); 852 OHOS::EventFwk::CommonEventData data; 853 data.SetWant(want); 854 int callState = 0; 855 DEVICE_MONITOR->SetCallState(data, callState); 856 want.SetParam("state", StateType::CALL_STATUS_INCOMING); 857 data.SetWant(want); 858 callState = 0; 859 DEVICE_MONITOR->SetCallState(data, callState); 860 861 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 862 keyEvent->SetKeyCode(KeyEvent::KEYCODE_VOLUME_UP); 863 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 864 } 865 866 /** 867 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_004 868 * @tc.desc: Test ring mute 869 * @tc.type: FUNC 870 * @tc.require: 871 */ 872 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_004, TestSize.Level1) 873 { 874 CALL_TEST_DEBUG; 875 KeySubscriberHandler keySubscriberHandler; 876 OHOS::EventFwk::Want want; 877 want.SetParam("state", StateType::CALL_STATUS_DISCONNECTED); 878 OHOS::EventFwk::CommonEventData data; 879 data.SetWant(want); 880 int callState = 0; 881 DEVICE_MONITOR->SetCallState(data, callState); 882 want.SetParam("state", StateType::CALL_STATUS_INCOMING); 883 data.SetWant(want); 884 callState = 0; 885 DEVICE_MONITOR->SetCallState(data, callState); 886 887 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 888 keyEvent->SetKeyCode(KeyEvent::KEYCODE_F1); 889 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 890 } 891 892 /** 893 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_005 894 * @tc.desc: Test ring mute 895 * @tc.type: FUNC 896 * @tc.require: 897 */ 898 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_005, TestSize.Level1) 899 { 900 CALL_TEST_DEBUG; 901 KeySubscriberHandler keySubscriberHandler; 902 OHOS::EventFwk::Want want; 903 want.SetParam("state", StateType::CALL_STATUS_INCOMING); 904 OHOS::EventFwk::CommonEventData data; 905 data.SetWant(want); 906 int callState = 0; 907 DEVICE_MONITOR->SetCallState(data, callState); 908 909 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 910 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 911 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 912 } 913 914 /** 915 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_006 916 * @tc.desc: Test ring mute 917 * @tc.type: FUNC 918 * @tc.require: 919 */ 920 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_006, TestSize.Level1) 921 { 922 CALL_TEST_DEBUG; 923 KeySubscriberHandler keySubscriberHandler; 924 OHOS::EventFwk::Want want; 925 want.SetParam("state", StateType::CALL_STATUS_DISCONNECTED); 926 OHOS::EventFwk::CommonEventData data; 927 data.SetWant(want); 928 int callState = 0; 929 DEVICE_MONITOR->SetCallState(data, callState); 930 want.SetParam("state", StateType::CALL_STATUS_INCOMING); 931 data.SetWant(want); 932 callState = 0; 933 DEVICE_MONITOR->SetCallState(data, callState); 934 935 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 936 keyEvent->SetKeyCode(KeyEvent::KEYCODE_VOLUME_DOWN); 937 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 938 } 939 940 /** 941 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_007 942 * @tc.desc: Test ring mute 943 * @tc.type: FUNC 944 * @tc.require: 945 */ 946 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_007, TestSize.Level1) 947 { 948 CALL_TEST_DEBUG; 949 KeySubscriberHandler keySubscriberHandler; 950 OHOS::EventFwk::Want want; 951 want.SetParam("state", StateType::CALL_STATUS_DISCONNECTED); 952 OHOS::EventFwk::CommonEventData data; 953 data.SetWant(want); 954 int callState = 0; 955 DEVICE_MONITOR->SetCallState(data, callState); 956 957 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 958 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 959 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 960 } 961 962 /** 963 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_008 964 * @tc.desc: Test ring mute 965 * @tc.type: FUNC 966 * @tc.require: 967 */ 968 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_008, TestSize.Level1) 969 { 970 CALL_TEST_DEBUG; 971 KeySubscriberHandler keySubscriberHandler; 972 973 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 974 keyEvent->SetKeyCode(KeyEvent::KEYCODE_VOLUME_DOWN); 975 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 976 } 977 978 /** 979 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_009 980 * @tc.desc: Test ring mute 981 * @tc.type: FUNC 982 * @tc.require: 983 */ 984 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_009, TestSize.Level1) 985 { 986 CALL_TEST_DEBUG; 987 KeySubscriberHandler keySubscriberHandler; 988 989 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 990 keyEvent->SetKeyCode(KeyEvent::KEYCODE_VOLUME_UP); 991 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 992 } 993 #endif // OHOS_BUILD_ENABLE_CALL_MANAGER 994 995 /** 996 * @tc.name: KeySubscriberHandlerTest_SubscribeKeyEvent_002 997 * @tc.desc: Test subscribe keyEvent 998 * @tc.type: FUNC 999 * @tc.require: 1000 */ 1001 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_SubscribeKeyEvent_002, TestSize.Level1) 1002 { 1003 CALL_DEBUG_ENTER; 1004 KeySubscriberHandler handler; 1005 int32_t subscribeId = 1; 1006 SessionPtr sess = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 1007 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 1008 std::set<int32_t> preKeys; 1009 preKeys.insert(1); 1010 keyOption->SetPreKeys(preKeys); 1011 ASSERT_NE(handler.SubscribeKeyEvent(sess, subscribeId, keyOption), RET_OK); 1012 1013 preKeys.insert(2); 1014 preKeys.insert(3); 1015 preKeys.insert(4); 1016 preKeys.insert(5); 1017 preKeys.insert(6); 1018 keyOption->SetPreKeys(preKeys); 1019 ASSERT_NE(handler.SubscribeKeyEvent(sess, subscribeId, keyOption), RET_OK); 1020 } 1021 1022 /** 1023 * @tc.name: KeySubscriberHandlerTest_IsEqualKeyOption 1024 * @tc.desc: Test Is Equal KeyOption 1025 * @tc.type: FUNC 1026 * @tc.require: 1027 */ 1028 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsEqualKeyOption, TestSize.Level1) 1029 { 1030 CALL_DEBUG_ENTER; 1031 KeySubscriberHandler handler; 1032 std::shared_ptr<KeyOption> newOption = std::make_shared<KeyOption>(); 1033 std::shared_ptr<KeyOption> oldOption = std::make_shared<KeyOption>(); 1034 std::set<int32_t> preKeys; 1035 std::set<int32_t> pressedKeys; 1036 preKeys.insert(1); 1037 pressedKeys.insert(1); 1038 newOption->SetPreKeys(preKeys); 1039 oldOption->SetPreKeys(pressedKeys); 1040 newOption->SetFinalKey(1); 1041 oldOption->SetFinalKey(2); 1042 ASSERT_FALSE(handler.IsEqualKeyOption(newOption, oldOption)); 1043 1044 oldOption->SetFinalKey(1); 1045 newOption->SetFinalKeyDown(true); 1046 oldOption->SetFinalKeyDown(false); 1047 ASSERT_FALSE(handler.IsEqualKeyOption(newOption, oldOption)); 1048 oldOption->SetFinalKeyDown(true); 1049 1050 newOption->SetFinalKeyDownDuration(100); 1051 oldOption->SetFinalKeyDownDuration(150); 1052 ASSERT_FALSE(handler.IsEqualKeyOption(newOption, oldOption)); 1053 oldOption->SetFinalKeyDownDuration(100); 1054 1055 newOption->SetFinalKeyUpDelay(100); 1056 oldOption->SetFinalKeyUpDelay(150); 1057 ASSERT_FALSE(handler.IsEqualKeyOption(newOption, oldOption)); 1058 oldOption->SetFinalKeyUpDelay(100); 1059 ASSERT_TRUE(handler.IsEqualKeyOption(newOption, oldOption)); 1060 } 1061 1062 /** 1063 * @tc.name: KeySubscriberHandlerTest_IsEnableCombineKey_003 1064 * @tc.desc: Test Is Enable CombineKey 1065 * @tc.type: FUNC 1066 * @tc.require: 1067 */ 1068 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsEnableCombineKey_003, TestSize.Level1) 1069 { 1070 CALL_DEBUG_ENTER; 1071 KeySubscriberHandler handler; 1072 KeyEvent::KeyItem item; 1073 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1074 handler.enableCombineKey_ = false; 1075 keyEvent->SetKeyCode(KeyEvent::KEYCODE_BRIGHTNESS_DOWN); 1076 item.SetKeyCode(KeyEvent::KEYCODE_A); 1077 keyEvent->AddKeyItem(item); 1078 ASSERT_TRUE(handler.IsEnableCombineKey(keyEvent)); 1079 1080 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 1081 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_UP); 1082 ASSERT_TRUE(handler.IsEnableCombineKey(keyEvent)); 1083 1084 item.SetKeyCode(KeyEvent::KEYCODE_B); 1085 keyEvent->AddKeyItem(item); 1086 ASSERT_FALSE(handler.IsEnableCombineKey(keyEvent)); 1087 1088 keyEvent->SetKeyCode(KeyEvent::KEYCODE_DPAD_RIGHT); 1089 ASSERT_FALSE(handler.IsEnableCombineKey(keyEvent)); 1090 1091 keyEvent->SetKeyCode(KeyEvent::KEYCODE_L); 1092 ASSERT_FALSE(handler.IsEnableCombineKey(keyEvent)); 1093 } 1094 1095 /** 1096 * @tc.name: KeySubscriberHandlerTest_IsEnableCombineKey_004 1097 * @tc.desc: Test Is Enable CombineKey 1098 * @tc.type: FUNC 1099 * @tc.require: 1100 */ 1101 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsEnableCombineKey_004, TestSize.Level1) 1102 { 1103 CALL_DEBUG_ENTER; 1104 KeySubscriberHandler handler; 1105 KeyEvent::KeyItem item; 1106 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1107 ASSERT_NE(keyEvent, nullptr); 1108 handler.enableCombineKey_ = false; 1109 keyEvent->SetKeyCode(KeyEvent::KEYCODE_L); 1110 item.SetKeyCode(KeyEvent::KEYCODE_L); 1111 keyEvent->AddKeyItem(item); 1112 ASSERT_TRUE(handler.IsEnableCombineKey(keyEvent)); 1113 } 1114 1115 /** 1116 * @tc.name: KeySubscriberHandlerTest_IsEnableCombineKey_005 1117 * @tc.desc: Test Is Enable CombineKey 1118 * @tc.type: FUNC 1119 * @tc.require: 1120 */ 1121 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsEnableCombineKey_005, TestSize.Level1) 1122 { 1123 CALL_DEBUG_ENTER; 1124 KeySubscriberHandler handler; 1125 KeyEvent::KeyItem item; 1126 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1127 ASSERT_NE(keyEvent, nullptr); 1128 handler.enableCombineKey_ = false; 1129 keyEvent->SetKeyCode(KeyEvent::KEYCODE_L); 1130 item.SetKeyCode(KeyEvent::KEYCODE_META_LEFT); 1131 keyEvent->AddKeyItem(item); 1132 ASSERT_TRUE(handler.IsEnableCombineKey(keyEvent)); 1133 } 1134 1135 /** 1136 * @tc.name: KeySubscriberHandlerTest_IsEnableCombineKey_006 1137 * @tc.desc: Test Is Enable CombineKey 1138 * @tc.type: FUNC 1139 * @tc.require: 1140 */ 1141 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsEnableCombineKey_006, TestSize.Level1) 1142 { 1143 CALL_DEBUG_ENTER; 1144 KeySubscriberHandler handler; 1145 KeyEvent::KeyItem item; 1146 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1147 ASSERT_NE(keyEvent, nullptr); 1148 handler.enableCombineKey_ = false; 1149 keyEvent->SetKeyCode(KeyEvent::KEYCODE_L); 1150 item.SetKeyCode(KeyEvent::KEYCODE_META_RIGHT); 1151 keyEvent->AddKeyItem(item); 1152 ASSERT_TRUE(handler.IsEnableCombineKey(keyEvent)); 1153 } 1154 1155 /** 1156 * @tc.name: KeySubscriberHandlerTest_RemoveSubscriber 1157 * @tc.desc: Test Remove Subscriber 1158 * @tc.type: FUNC 1159 * @tc.require: 1160 */ 1161 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_RemoveSubscriber, TestSize.Level1) 1162 { 1163 CALL_DEBUG_ENTER; 1164 KeySubscriberHandler handler; 1165 int32_t subscribeId = 2; 1166 int32_t id = 1; 1167 std::list<std::shared_ptr<KeySubscriberHandler::Subscriber>> subscriberList; 1168 SessionPtr session = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 1169 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 1170 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 1171 std::make_shared<KeySubscriberHandler::Subscriber>(id, session, keyOption); 1172 subscriberList.push_back(subscriber); 1173 handler.subscriberMap_.insert(std::make_pair(keyOption, subscriberList)); 1174 ASSERT_EQ(handler.RemoveSubscriber(session, subscribeId, true), RET_ERR); 1175 subscribeId = 1; 1176 ASSERT_EQ(handler.RemoveSubscriber(session, subscribeId, true), RET_OK); 1177 } 1178 1179 /** 1180 * @tc.name: KeySubscriberHandlerTest_IsFunctionKey 1181 * @tc.desc: Test IsFunctionKey 1182 * @tc.type: FUNC 1183 * @tc.require: 1184 */ 1185 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsFunctionKey, TestSize.Level1) 1186 { 1187 CALL_DEBUG_ENTER; 1188 KeySubscriberHandler handler; 1189 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1190 ASSERT_NE(keyEvent, nullptr); 1191 keyEvent->SetKeyCode(KeyEvent::KEYCODE_BRIGHTNESS_UP); 1192 ASSERT_TRUE(handler.IsFunctionKey(keyEvent)); 1193 keyEvent->SetKeyCode(KeyEvent::KEYCODE_VOLUME_UP); 1194 ASSERT_TRUE(handler.IsFunctionKey(keyEvent)); 1195 keyEvent->SetKeyCode(KeyEvent::KEYCODE_VOLUME_DOWN); 1196 ASSERT_TRUE(handler.IsFunctionKey(keyEvent)); 1197 keyEvent->SetKeyCode(KeyEvent::KEYCODE_VOLUME_MUTE); 1198 ASSERT_TRUE(handler.IsFunctionKey(keyEvent)); 1199 keyEvent->SetKeyCode(KeyEvent::KEYCODE_MUTE); 1200 ASSERT_TRUE(handler.IsFunctionKey(keyEvent)); 1201 keyEvent->SetKeyCode(KeyEvent::KEYCODE_SWITCHVIDEOMODE); 1202 ASSERT_TRUE(handler.IsFunctionKey(keyEvent)); 1203 keyEvent->SetKeyCode(KeyEvent::KEYCODE_WLAN); 1204 ASSERT_FALSE(handler.IsFunctionKey(keyEvent)); 1205 keyEvent->SetKeyCode(KeyEvent::KEYCODE_CONFIG); 1206 ASSERT_FALSE(handler.IsFunctionKey(keyEvent)); 1207 } 1208 1209 /** 1210 * @tc.name: KeySubscriberHandlerTest_OnSubscribeKeyEvent 1211 * @tc.desc: Test OnSubscribeKeyEvent 1212 * @tc.type: FUNC 1213 * @tc.require: 1214 */ 1215 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_OnSubscribeKeyEvent, TestSize.Level1) 1216 { 1217 CALL_DEBUG_ENTER; 1218 KeySubscriberHandler handler; 1219 KeyEvent::KeyItem item; 1220 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1221 ASSERT_NE(keyEvent, nullptr); 1222 handler.enableCombineKey_ = false; 1223 keyEvent->SetKeyCode(KeyEvent::KEYCODE_BRIGHTNESS_DOWN); 1224 item.SetKeyCode(KeyEvent::KEYCODE_A); 1225 keyEvent->AddKeyItem(item); 1226 item.SetKeyCode(KeyEvent::KEYCODE_B); 1227 keyEvent->AddKeyItem(item); 1228 ASSERT_FALSE(handler.OnSubscribeKeyEvent(keyEvent)); 1229 1230 handler.enableCombineKey_ = true; 1231 handler.hasEventExecuting_ = true; 1232 handler.keyEvent_ = KeyEvent::Create(); 1233 ASSERT_NE(handler.keyEvent_, nullptr); 1234 handler.keyEvent_->SetKeyCode(KeyEvent::KEYCODE_BRIGHTNESS_DOWN); 1235 handler.keyEvent_->SetKeyAction(KeyEvent::KEY_ACTION_UP); 1236 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_UP); 1237 item.SetKeyCode(KeyEvent::KEYCODE_A); 1238 handler.keyEvent_->AddKeyItem(item); 1239 item.SetKeyCode(KeyEvent::KEYCODE_B); 1240 handler.keyEvent_->AddKeyItem(item); 1241 ASSERT_TRUE(handler.OnSubscribeKeyEvent(keyEvent)); 1242 1243 handler.hasEventExecuting_ = false; 1244 handler.needSkipPowerKeyUp_ = true; 1245 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 1246 ASSERT_TRUE(handler.OnSubscribeKeyEvent(keyEvent)); 1247 1248 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_UNKNOWN); 1249 ASSERT_FALSE(handler.OnSubscribeKeyEvent(keyEvent)); 1250 } 1251 1252 /** 1253 * @tc.name: KeySubscriberHandlerTest_OnSessionDelete 1254 * @tc.desc: Test OnSessionDelete 1255 * @tc.type: FUNC 1256 * @tc.require: 1257 */ 1258 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_OnSessionDelete, TestSize.Level1) 1259 { 1260 CALL_DEBUG_ENTER; 1261 KeySubscriberHandler handler; 1262 int32_t id = 1; 1263 std::list<std::shared_ptr<KeySubscriberHandler::Subscriber>> subscriberList; 1264 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 1265 SessionPtr session = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 1266 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 1267 std::make_shared<KeySubscriberHandler::Subscriber>(id, session, keyOption); 1268 subscriberList.push_back(subscriber); 1269 handler.subscriberMap_.insert(std::make_pair(keyOption, subscriberList)); 1270 SessionPtr sess = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 1271 ASSERT_NO_FATAL_FAILURE(handler.OnSessionDelete(sess)); 1272 ASSERT_NO_FATAL_FAILURE(handler.OnSessionDelete(session)); 1273 } 1274 1275 /** 1276 * @tc.name: KeySubscriberHandlerTest_IsPreKeysMatch 1277 * @tc.desc: Test IsPreKeysMatch 1278 * @tc.type: FUNC 1279 * @tc.require: 1280 */ 1281 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsPreKeysMatch, TestSize.Level1) 1282 { 1283 CALL_DEBUG_ENTER; 1284 KeySubscriberHandler handler; 1285 std::set<int32_t> preKeys; 1286 std::vector<int32_t> pressedKeys; 1287 preKeys.insert(KeyEvent::KEYCODE_A); 1288 pressedKeys.push_back(KeyEvent::KEYCODE_B); 1289 ASSERT_FALSE(handler.IsPreKeysMatch(preKeys, pressedKeys)); 1290 preKeys.clear(); 1291 pressedKeys.clear(); 1292 preKeys.insert(KeyEvent::KEYCODE_C); 1293 pressedKeys.push_back(KeyEvent::KEYCODE_C); 1294 ASSERT_TRUE(handler.IsPreKeysMatch(preKeys, pressedKeys)); 1295 } 1296 1297 /** 1298 * @tc.name: KeySubscriberHandlerTest_IsMatchForegroundPid 1299 * @tc.desc: Test Is Match Foreground Pid 1300 * @tc.type: FUNC 1301 * @tc.require: 1302 */ 1303 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsMatchForegroundPid, TestSize.Level1) 1304 { 1305 CALL_DEBUG_ENTER; 1306 KeySubscriberHandler handler; 1307 int32_t id = 1; 1308 SessionPtr session = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 1309 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 1310 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 1311 std::make_shared<KeySubscriberHandler::Subscriber>(id, session, keyOption); 1312 std::list<std::shared_ptr<KeySubscriberHandler::Subscriber>> subscriberList; 1313 std::set<int32_t> foregroundPids; 1314 subscriberList.push_back(subscriber); 1315 foregroundPids.insert(1); 1316 ASSERT_FALSE(handler.IsMatchForegroundPid(subscriberList, foregroundPids)); 1317 1318 foregroundPids.insert(100); 1319 ASSERT_TRUE(handler.IsMatchForegroundPid(subscriberList, foregroundPids)); 1320 } 1321 1322 /** 1323 * @tc.name: KeySubscriberHandlerTest_NotifyKeyDownSubscriber 1324 * @tc.desc: Test Notify Key Down Subscriber 1325 * @tc.type: FUNC 1326 * @tc.require: 1327 */ 1328 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifyKeyDownSubscriber, TestSize.Level1) 1329 { 1330 CALL_DEBUG_ENTER; 1331 KeySubscriberHandler handler; 1332 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1333 ASSERT_NE(keyEvent, nullptr); 1334 int32_t id = 1; 1335 bool handled = false; 1336 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 1337 SessionPtr session = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 1338 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 1339 std::make_shared<KeySubscriberHandler::Subscriber>(id, session, keyOption); 1340 std::list<std::shared_ptr<KeySubscriberHandler::Subscriber>> subscriberList; 1341 subscriberList.push_back(subscriber); 1342 keyOption->SetFinalKeyDownDuration(100); 1343 ASSERT_NO_FATAL_FAILURE(handler.NotifyKeyDownSubscriber(keyEvent, keyOption, subscriberList, handled)); 1344 } 1345 1346 /** 1347 * @tc.name: KeySubscriberHandlerTest_NotifyKeyDownRightNow 1348 * @tc.desc: Test Notify Key Down Right Now 1349 * @tc.type: FUNC 1350 * @tc.require: 1351 */ 1352 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifyKeyDownRightNow, TestSize.Level1) 1353 { 1354 CALL_DEBUG_ENTER; 1355 KeySubscriberHandler handler; 1356 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1357 ASSERT_NE(keyEvent, nullptr); 1358 int32_t id = 1; 1359 bool handled = false; 1360 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 1361 SessionPtr session = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 1362 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 1363 std::make_shared<KeySubscriberHandler::Subscriber>(id, session, keyOption); 1364 std::list<std::shared_ptr<KeySubscriberHandler::Subscriber>> subscriberList; 1365 subscriberList.push_back(subscriber); 1366 handler.isForegroundExits_ = true; 1367 ASSERT_NO_FATAL_FAILURE(handler.NotifyKeyDownRightNow(keyEvent, subscriberList, true, handled)); 1368 1369 handler.isForegroundExits_ = false; 1370 handler.foregroundPids_.insert(UDS_PID); 1371 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 1372 ASSERT_NO_FATAL_FAILURE(handler.NotifyKeyDownRightNow(keyEvent, subscriberList, true, handled)); 1373 } 1374 1375 /** 1376 * @tc.name: KeySubscriberHandlerTest_NotifyKeyDownDelay 1377 * @tc.desc: Test Notify KeyDown Delay 1378 * @tc.type: FUNC 1379 * @tc.require: 1380 */ 1381 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifyKeyDownDelay, TestSize.Level1) 1382 { 1383 CALL_DEBUG_ENTER; 1384 KeySubscriberHandler handler; 1385 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1386 ASSERT_NE(keyEvent, nullptr); 1387 int32_t id = 1; 1388 bool handled = false; 1389 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 1390 SessionPtr session = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 1391 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 1392 std::make_shared<KeySubscriberHandler::Subscriber>(id, session, keyOption); 1393 std::list<std::shared_ptr<KeySubscriberHandler::Subscriber>> subscriberList; 1394 subscriber->timerId_ = 1; 1395 subscriberList.push_back(subscriber); 1396 handler.isForegroundExits_ = true; 1397 ASSERT_NO_FATAL_FAILURE(handler.NotifyKeyDownDelay(keyEvent, subscriberList, handled)); 1398 1399 handler.isForegroundExits_ = false; 1400 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 1401 handler.foregroundPids_.insert(UDS_PID); 1402 ASSERT_NO_FATAL_FAILURE(handler.NotifyKeyDownDelay(keyEvent, subscriberList, handled)); 1403 } 1404 1405 /** 1406 * @tc.name: KeySubscriberHandlerTest_NotifyKeyUpSubscriber 1407 * @tc.desc: Test Notify KeyUp Subscriber 1408 * @tc.type: FUNC 1409 * @tc.require: 1410 */ 1411 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifyKeyUpSubscriber, TestSize.Level1) 1412 { 1413 CALL_DEBUG_ENTER; 1414 KeySubscriberHandler handler; 1415 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1416 ASSERT_NE(keyEvent, nullptr); 1417 int32_t id = 1; 1418 bool handled = false; 1419 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 1420 SessionPtr session = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 1421 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 1422 std::make_shared<KeySubscriberHandler::Subscriber>(id, session, keyOption); 1423 std::list<std::shared_ptr<KeySubscriberHandler::Subscriber>> subscriberList; 1424 subscriber->timerId_ = 1; 1425 keyOption->SetFinalKeyUpDelay(1000); 1426 subscriberList.push_back(subscriber); 1427 ASSERT_NO_FATAL_FAILURE(handler.NotifyKeyUpSubscriber(keyEvent, subscriberList, handled)); 1428 handler.isForegroundExits_ = true; 1429 handler.foregroundPids_.insert(UDS_PID); 1430 ASSERT_NO_FATAL_FAILURE(handler.NotifyKeyUpSubscriber(keyEvent, subscriberList, handled)); 1431 handler.foregroundPids_.erase(UDS_PID); 1432 ASSERT_NO_FATAL_FAILURE(handler.NotifyKeyUpSubscriber(keyEvent, subscriberList, handled)); 1433 } 1434 1435 /** 1436 * @tc.name: KeySubscriberHandlerTest_IsKeyEventSubscribed 1437 * @tc.desc: Test IsKeyEventSubscribed 1438 * @tc.type: FUNC 1439 * @tc.require: 1440 */ 1441 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsKeyEventSubscribed, TestSize.Level1) 1442 { 1443 KeySubscriberHandler handler; 1444 int32_t id = 1; 1445 int32_t keyCode = KeyEvent::KEYCODE_ALT_LEFT; 1446 int32_t trrigerType = KeyEvent::KEY_ACTION_DOWN; 1447 SessionPtr session = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 1448 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 1449 keyOption->SetFinalKeyDown(false); 1450 keyOption->SetFinalKey(KeyEvent::KEYCODE_CTRL_LEFT); 1451 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 1452 std::make_shared<KeySubscriberHandler::Subscriber>(id, session, keyOption); 1453 std::list<std::shared_ptr<KeySubscriberHandler::Subscriber>> subscriberList; 1454 subscriberList.push_back(subscriber); 1455 handler.subscriberMap_.insert(std::make_pair(keyOption, subscriberList)); 1456 ASSERT_FALSE(handler.IsKeyEventSubscribed(keyCode, trrigerType)); 1457 1458 for (auto &iter : handler.subscriberMap_) { 1459 iter.first->SetFinalKeyDown(true); 1460 } 1461 keyCode = KeyEvent::KEYCODE_CTRL_LEFT; 1462 ASSERT_TRUE(handler.IsKeyEventSubscribed(keyCode, trrigerType)); 1463 } 1464 1465 /** 1466 * @tc.name: KeySubscriberHandlerTest_RemoveKeyCode 1467 * @tc.desc: Test RemoveKeyCode 1468 * @tc.type: FUNC 1469 * @tc.require: 1470 */ 1471 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_RemoveKeyCode, TestSize.Level1) 1472 { 1473 KeySubscriberHandler handler; 1474 int32_t keyCode = KeyEvent::KEYCODE_A; 1475 std::vector<int32_t> keyCodes { KeyEvent::KEYCODE_A, KeyEvent::KEYCODE_B }; 1476 ASSERT_NO_FATAL_FAILURE(handler.RemoveKeyCode(keyCode, keyCodes)); 1477 keyCode = KeyEvent::KEYCODE_C; 1478 ASSERT_NO_FATAL_FAILURE(handler.RemoveKeyCode(keyCode, keyCodes)); 1479 } 1480 1481 /** 1482 * @tc.name: KeySubscriberHandlerTest_IsRepeatedKeyEvent 1483 * @tc.desc: Test IsRepeatedKeyEvent 1484 * @tc.type: FUNC 1485 * @tc.require: 1486 */ 1487 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsRepeatedKeyEvent, TestSize.Level1) 1488 { 1489 KeySubscriberHandler handler; 1490 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1491 ASSERT_NE(keyEvent, nullptr); 1492 ASSERT_FALSE(handler.IsRepeatedKeyEvent(keyEvent)); 1493 handler.keyEvent_ = KeyEvent::Create(); 1494 ASSERT_NE(keyEvent, nullptr); 1495 handler.hasEventExecuting_ = true; 1496 handler.keyEvent_->SetKeyCode(KeyEvent::KEYCODE_A); 1497 keyEvent->SetKeyCode(KeyEvent::KEYCODE_B); 1498 ASSERT_FALSE(handler.IsRepeatedKeyEvent(keyEvent)); 1499 keyEvent->SetKeyCode(KeyEvent::KEYCODE_A); 1500 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_UP); 1501 handler.keyEvent_->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 1502 ASSERT_FALSE(handler.IsRepeatedKeyEvent(keyEvent)); 1503 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 1504 KeyEvent::KeyItem item; 1505 item.SetKeyCode(KeyEvent::KEYCODE_A); 1506 handler.keyEvent_->AddKeyItem(item); 1507 ASSERT_FALSE(handler.IsRepeatedKeyEvent(keyEvent)); 1508 item.SetKeyCode(KeyEvent::KEYCODE_B); 1509 keyEvent->AddKeyItem(item); 1510 ASSERT_FALSE(handler.IsRepeatedKeyEvent(keyEvent)); 1511 item.SetKeyCode(KeyEvent::KEYCODE_B); 1512 handler.keyEvent_->AddKeyItem(item); 1513 item.SetKeyCode(KeyEvent::KEYCODE_D); 1514 keyEvent->AddKeyItem(item); 1515 ASSERT_FALSE(handler.IsRepeatedKeyEvent(keyEvent)); 1516 } 1517 1518 #ifdef OHOS_BUILD_ENABLE_CALL_MANAGER 1519 /** 1520 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_010 1521 * @tc.desc: Test the funcation HandleRingMute 1522 * @tc.type: FUNC 1523 * @tc.require: 1524 */ 1525 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_010, TestSize.Level1) 1526 { 1527 CALL_TEST_DEBUG; 1528 KeySubscriberHandler handler; 1529 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1530 ASSERT_NE(keyEvent, nullptr); 1531 keyEvent->SetKeyCode(KeyEvent::KEYCODE_VOLUME_DOWN); 1532 OHOS::EventFwk::Want want; 1533 want.SetParam("state", StateType::CALL_STATUS_INCOMING); 1534 OHOS::EventFwk::CommonEventData data; 1535 data.SetWant(want); 1536 int32_t callState = 0; 1537 DEVICE_MONITOR->SetCallState(data, callState); 1538 DeviceEventMonitor monitor; 1539 monitor.hasHandleRingMute_ = false; 1540 bool ret = handler.HandleRingMute(keyEvent); 1541 ASSERT_FALSE(ret); 1542 monitor.hasHandleRingMute_ = true; 1543 ret = handler.HandleRingMute(keyEvent); 1544 ASSERT_FALSE(ret); 1545 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 1546 ret = handler.HandleRingMute(keyEvent); 1547 ASSERT_FALSE(ret); 1548 want.SetParam("state", StateType::CALL_STATUS_ALERTING); 1549 data.SetWant(want); 1550 DEVICE_MONITOR->SetCallState(data, callState); 1551 ret = handler.HandleRingMute(keyEvent); 1552 ASSERT_FALSE(ret); 1553 } 1554 #endif // OHOS_BUILD_ENABLE_CALL_MANAGER 1555 1556 /** 1557 * @tc.name: KeySubscriberHandlerTest_OnSubscribeKeyEvent_002 1558 * @tc.desc: Test the funcation OnSubscribeKeyEvent 1559 * @tc.type: FUNC 1560 * @tc.require: 1561 */ 1562 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_OnSubscribeKeyEvent_002, TestSize.Level1) 1563 { 1564 CALL_TEST_DEBUG; 1565 KeySubscriberHandler handler; 1566 OHOS::EventFwk::Want want; 1567 want.SetParam("state", StateType::CALL_STATUS_DISCONNECTED); 1568 OHOS::EventFwk::CommonEventData data; 1569 data.SetWant(want); 1570 int callState = 0; 1571 DEVICE_MONITOR->SetCallState(data, callState); 1572 want.SetParam("state", StateType::CALL_STATUS_INCOMING); 1573 data.SetWant(want); 1574 callState = 0; 1575 DEVICE_MONITOR->SetCallState(data, callState); 1576 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1577 keyEvent->SetKeyCode(KeyEvent::KEYCODE_VOLUME_UP); 1578 bool ret = handler.OnSubscribeKeyEvent(keyEvent); 1579 ASSERT_FALSE(ret); 1580 } 1581 1582 /** 1583 * @tc.name: KeySubscriberHandlerTest_OnSubscribeKeyEvent_003 1584 * @tc.desc: Test the funcation OnSubscribeKeyEvent 1585 * @tc.type: FUNC 1586 * @tc.require: 1587 */ 1588 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_OnSubscribeKeyEvent_003, TestSize.Level1) 1589 { 1590 CALL_TEST_DEBUG; 1591 KeySubscriberHandler handler; 1592 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1593 ASSERT_NE(keyEvent, nullptr); 1594 handler.needSkipPowerKeyUp_ = true; 1595 KeyEvent::KeyItem item; 1596 item.SetKeyCode(KeyEvent::KEYCODE_POWER); 1597 keyEvent->AddKeyItem(item); 1598 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 1599 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_UP); 1600 ASSERT_TRUE(handler.OnSubscribeKeyEvent(keyEvent)); 1601 } 1602 1603 /** 1604 * @tc.name: KeySubscriberHandlerTest_NotifySubscriber_002 1605 * @tc.desc: Test the funcation NotifySubscriber 1606 * @tc.type: FUNC 1607 * @tc.require: 1608 */ 1609 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifySubscriber_002, TestSize.Level1) 1610 { 1611 CALL_TEST_DEBUG; 1612 KeySubscriberHandler handler; 1613 SessionPtr sess; 1614 std::shared_ptr<KeyOption> keyOption; 1615 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1616 ASSERT_NE(keyEvent, nullptr); 1617 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 1618 KeyEvent::KeyItem item; 1619 item.SetKeyCode(KeyEvent::KEYCODE_POWER); 1620 keyEvent->AddKeyItem(item); 1621 keyEvent->SetKeyCode(KeyEvent::KEYCODE_CAMERA); 1622 ASSERT_NO_FATAL_FAILURE(handler.NotifySubscriber(keyEvent, subscriber)); 1623 } 1624 1625 /** 1626 * @tc.name: KeySubscriberHandlerTest_AddTimer_001 1627 * @tc.desc: Test the funcation AddTimer 1628 * @tc.type: FUNC 1629 * @tc.require: 1630 */ 1631 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_AddTimer_001, TestSize.Level1) 1632 { 1633 CALL_TEST_DEBUG; 1634 KeySubscriberHandler handler; 1635 int32_t id = 1; 1636 SessionPtr session = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 1637 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 1638 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 1639 std::make_shared<KeySubscriberHandler::Subscriber>(id, session, keyOption); 1640 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1641 ASSERT_NE(keyEvent, nullptr); 1642 subscriber->timerId_ = 1; 1643 bool ret = handler.AddTimer(subscriber, keyEvent); 1644 ASSERT_TRUE(ret); 1645 subscriber->timerId_ = -1; 1646 keyOption->isFinalKeyDown_ = true; 1647 ret = handler.AddTimer(subscriber, keyEvent); 1648 ASSERT_TRUE(ret); 1649 keyOption->isFinalKeyDown_ = false; 1650 ret = handler.AddTimer(subscriber, keyEvent); 1651 ASSERT_TRUE(ret); 1652 } 1653 1654 /** 1655 * @tc.name: KeySubscriberHandlerTest_HandleKeyDown_002 1656 * @tc.desc: Test the funcation HandleKeyDown 1657 * @tc.type: FUNC 1658 * @tc.require: 1659 */ 1660 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleKeyDown_002, TestSize.Level1) 1661 { 1662 CALL_DEBUG_ENTER; 1663 KeySubscriberHandler handler; 1664 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1665 ASSERT_NE(keyEvent, nullptr); 1666 auto keyOption = std::make_shared<KeyOption>(); 1667 keyOption->isFinalKeyDown_ = false; 1668 SessionPtr sess; 1669 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 1670 std::list<std::shared_ptr<OHOS::MMI::KeySubscriberHandler::Subscriber>> subscribers; 1671 subscribers.push_back(subscriber); 1672 handler.subscriberMap_.insert(std::make_pair(keyOption, subscribers)); 1673 bool ret = handler.HandleKeyDown(keyEvent); 1674 ASSERT_FALSE(ret); 1675 keyOption->isFinalKeyDown_ = true; 1676 keyOption->finalKey_ = true; 1677 subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 1678 subscribers.push_back(subscriber); 1679 handler.subscriberMap_.insert(std::make_pair(keyOption, subscribers)); 1680 KeyEvent::KeyItem item; 1681 item.SetKeyCode(KeyEvent::KEYCODE_POWER); 1682 keyEvent->AddKeyItem(item); 1683 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 1684 ret = handler.HandleKeyDown(keyEvent); 1685 ASSERT_FALSE(ret); 1686 keyOption->finalKey_ = false; 1687 std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 1688 subscribers.push_back(subscriber); 1689 handler.subscriberMap_.insert(std::make_pair(keyOption, subscribers)); 1690 ret = handler.HandleKeyDown(keyEvent); 1691 ASSERT_FALSE(ret); 1692 keyEvent->SetKeyCode(KeyEvent::KEYCODE_CAMERA); 1693 ret = handler.HandleKeyDown(keyEvent); 1694 ASSERT_FALSE(ret); 1695 } 1696 1697 /** 1698 * @tc.name: KeySubscriberHandlerTest_HandleKeyUp_002 1699 * @tc.desc: Test the funcation HandleKeyUp 1700 * @tc.type: FUNC 1701 * @tc.require: 1702 */ 1703 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleKeyUp_002, TestSize.Level1) 1704 { 1705 CALL_DEBUG_ENTER; 1706 KeySubscriberHandler handler; 1707 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1708 ASSERT_NE(keyEvent, nullptr); 1709 auto keyOption = std::make_shared<KeyOption>(); 1710 keyOption->isFinalKeyDown_ = true; 1711 SessionPtr sess; 1712 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 1713 std::list<std::shared_ptr<OHOS::MMI::KeySubscriberHandler::Subscriber>> subscribers; 1714 subscribers.push_back(subscriber); 1715 handler.subscriberMap_.insert(std::make_pair(keyOption, subscribers)); 1716 bool ret = handler.HandleKeyUp(keyEvent); 1717 ASSERT_FALSE(ret); 1718 keyOption->isFinalKeyDown_ = false; 1719 keyOption->finalKey_ = 2; 1720 std::set<int32_t> tmp; 1721 for (auto i = 0; i < 5; i++) { 1722 tmp.insert(i); 1723 KeyEvent::KeyItem keyItem; 1724 keyItem.pressed_ = true; 1725 keyItem.SetKeyCode(i); 1726 keyItem.downTime_ = 2000; 1727 keyEvent->keys_.push_back(keyItem); 1728 } 1729 tmp.clear(); 1730 keyOption->SetPreKeys(tmp); 1731 keyOption->finalKeyDownDuration_ = 0; 1732 keyOption->finalKey_ = -1; 1733 keyEvent->SetKeyCode(-1); 1734 subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 1735 subscribers.push_back(subscriber); 1736 handler.subscriberMap_.insert(std::make_pair(keyOption, subscribers)); 1737 KEY_SHORTCUT_MGR->isCheckShortcut_ = true; 1738 ret = handler.HandleKeyUp(keyEvent); 1739 ASSERT_FALSE(ret); 1740 keyOption->finalKeyDownDuration_ = 3; 1741 keyOption->finalKey_ = 3; 1742 keyEvent->SetKeyCode(3); 1743 subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 1744 subscribers.push_back(subscriber); 1745 handler.subscriberMap_.insert(std::make_pair(keyOption, subscribers)); 1746 KEY_SHORTCUT_MGR->isCheckShortcut_ = true; 1747 ret = handler.HandleKeyUp(keyEvent); 1748 ASSERT_FALSE(ret); 1749 } 1750 1751 /** 1752 * @tc.name: KeySubscriberHandlerTest_HandleKeyUp_003 1753 * @tc.desc: Test the funcation HandleKeyUp 1754 * @tc.type: FUNC 1755 * @tc.require: 1756 */ 1757 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleKeyUp_003, TestSize.Level1) 1758 { 1759 CALL_DEBUG_ENTER; 1760 KeySubscriberHandler handler; 1761 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1762 ASSERT_NE(keyEvent, nullptr); 1763 auto keyOption = std::make_shared<KeyOption>(); 1764 keyOption->isFinalKeyDown_ = false; 1765 SessionPtr sess; 1766 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 1767 std::list<std::shared_ptr<OHOS::MMI::KeySubscriberHandler::Subscriber>> subscribers; 1768 keyOption->finalKey_ = 0; 1769 subscribers.push_back(subscriber); 1770 handler.subscriberMap_.insert(std::make_pair(keyOption, subscribers)); 1771 KEY_SHORTCUT_MGR->isCheckShortcut_ = true; 1772 keyEvent->SetKeyCode(-1); 1773 bool ret = false; 1774 ret = handler.HandleKeyUp(keyEvent); 1775 ASSERT_FALSE(ret); 1776 keyOption->finalKey_ = 2; 1777 std::set<int32_t> tmp; 1778 for (auto i = 0; i < 5; i++) { 1779 tmp.insert(i); 1780 KeyEvent::KeyItem keyItem; 1781 keyItem.pressed_ = true; 1782 keyItem.SetKeyCode(i); 1783 keyItem.downTime_ = 2000; 1784 keyEvent->keys_.push_back(keyItem); 1785 } 1786 keyOption->SetPreKeys(tmp); 1787 subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 1788 subscribers.push_back(subscriber); 1789 handler.subscriberMap_.insert(std::make_pair(keyOption, subscribers)); 1790 keyEvent->SetKeyCode(2); 1791 KEY_SHORTCUT_MGR->isCheckShortcut_ = true; 1792 ret = handler.HandleKeyUp(keyEvent); 1793 ASSERT_FALSE(ret); 1794 tmp.clear(); 1795 keyOption->SetPreKeys(tmp); 1796 keyOption->finalKey_ = 4; 1797 keyEvent->SetKeyCode(4); 1798 keyEvent->actionTime_ = 3000; 1799 keyOption->finalKeyDownDuration_ = 3; 1800 subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 1801 subscribers.push_back(subscriber); 1802 handler.subscriberMap_.insert(std::make_pair(keyOption, subscribers)); 1803 KEY_SHORTCUT_MGR->isCheckShortcut_ = true; 1804 ret = handler.HandleKeyUp(keyEvent); 1805 ASSERT_FALSE(ret); 1806 } 1807 1808 /** 1809 * @tc.name: KeySubscriberHandlerTest_HandleKeyUp_004 1810 * @tc.desc: Test the funcation HandleKeyUp 1811 * @tc.type: FUNC 1812 * @tc.require: 1813 */ 1814 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleKeyUp_004, TestSize.Level1) 1815 { 1816 CALL_DEBUG_ENTER; 1817 KeySubscriberHandler handler; 1818 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1819 ASSERT_NE(keyEvent, nullptr); 1820 auto keyOption = std::make_shared<KeyOption>(); 1821 keyOption->isFinalKeyDown_ = true; 1822 SessionPtr sess; 1823 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 1824 std::list<std::shared_ptr<OHOS::MMI::KeySubscriberHandler::Subscriber>> subscribers; 1825 subscribers.push_back(subscriber); 1826 handler.subscriberMap_.insert(std::make_pair(keyOption, subscribers)); 1827 bool ret = handler.HandleKeyUp(keyEvent); 1828 ASSERT_FALSE(ret); 1829 } 1830 1831 #ifdef OHOS_BUILD_ENABLE_CALL_MANAGER 1832 /** 1833 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_01 1834 * @tc.desc: Test the funcation HandleRingMute 1835 * @tc.type: FUNC 1836 * @tc.require: 1837 */ 1838 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_01, TestSize.Level1) 1839 { 1840 CALL_TEST_DEBUG; 1841 KeySubscriberHandler handler; 1842 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1843 ASSERT_NE(keyEvent, nullptr); 1844 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 1845 DeviceEventMonitor monitor; 1846 monitor.callState_ = StateType::CALL_STATUS_INCOMING; 1847 bool ret = handler.HandleRingMute(keyEvent); 1848 ASSERT_FALSE(ret); 1849 handler.HandleRingMute(keyEvent); 1850 monitor.hasHandleRingMute_ = false; 1851 ret = handler.HandleRingMute(keyEvent); 1852 ASSERT_FALSE(ret); 1853 monitor.hasHandleRingMute_ = true; 1854 ret = handler.HandleRingMute(keyEvent); 1855 ASSERT_FALSE(ret); 1856 monitor.callState_ = StateType::CALL_STATUS_DIALING; 1857 ret = handler.HandleRingMute(keyEvent); 1858 ASSERT_FALSE(ret); 1859 } 1860 1861 /** 1862 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_02 1863 * @tc.desc: Test ring mute 1864 * @tc.type: FUNC 1865 * @tc.require: 1866 */ 1867 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_02, TestSize.Level1) 1868 { 1869 CALL_TEST_DEBUG; 1870 KeySubscriberHandler keySubscriberHandler; 1871 1872 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1873 ASSERT_NE(keyEvent, nullptr); 1874 keyEvent->keyCode_ = KeyEvent::KEYCODE_VOLUME_DOWN; 1875 1876 DEVICE_MONITOR->callState_ = StateType::CALL_STATUS_INCOMING; 1877 auto callManagerClientPtr = DelayedSingleton<OHOS::Telephony::CallManagerClient>::GetInstance(); 1878 callManagerClientPtr = nullptr; 1879 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 1880 } 1881 1882 /** 1883 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_03 1884 * @tc.desc: Test ring mute 1885 * @tc.type: FUNC 1886 * @tc.require: 1887 */ 1888 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_03, TestSize.Level1) 1889 { 1890 CALL_TEST_DEBUG; 1891 KeySubscriberHandler keySubscriberHandler; 1892 1893 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1894 ASSERT_NE(keyEvent, nullptr); 1895 keyEvent->keyCode_ = KeyEvent::KEYCODE_VOLUME_DOWN; 1896 1897 DEVICE_MONITOR->callState_ = StateType::CALL_STATUS_INCOMING; 1898 auto callManagerClientPtr = DelayedSingleton<OHOS::Telephony::CallManagerClient>::GetInstance(); 1899 EXPECT_NE(callManagerClientPtr, nullptr); 1900 DEVICE_MONITOR->hasHandleRingMute_ = false; 1901 auto ret = callManagerClientPtr->MuteRinger(); 1902 EXPECT_NE(ret, ERR_OK); 1903 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 1904 } 1905 1906 /** 1907 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_04 1908 * @tc.desc: Test ring mute 1909 * @tc.type: FUNC 1910 * @tc.require: 1911 */ 1912 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_04, TestSize.Level1) 1913 { 1914 CALL_TEST_DEBUG; 1915 KeySubscriberHandler keySubscriberHandler; 1916 1917 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1918 ASSERT_NE(keyEvent, nullptr); 1919 keyEvent->keyCode_ = KeyEvent::KEYCODE_VOLUME_DOWN; 1920 1921 DEVICE_MONITOR->callState_ = StateType::CALL_STATUS_INCOMING; 1922 auto callManagerClientPtr = DelayedSingleton<OHOS::Telephony::CallManagerClient>::GetInstance(); 1923 EXPECT_NE(callManagerClientPtr, nullptr); 1924 DEVICE_MONITOR->hasHandleRingMute_ = false; 1925 keyEvent->keyCode_ = KeyEvent::KEYCODE_POWER; 1926 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 1927 } 1928 1929 /** 1930 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_05 1931 * @tc.desc: Test ring mute 1932 * @tc.type: FUNC 1933 * @tc.require: 1934 */ 1935 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_05, TestSize.Level1) 1936 { 1937 CALL_TEST_DEBUG; 1938 KeySubscriberHandler keySubscriberHandler; 1939 1940 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1941 ASSERT_NE(keyEvent, nullptr); 1942 keyEvent->keyCode_ = KeyEvent::KEYCODE_VOLUME_DOWN; 1943 1944 DEVICE_MONITOR->callState_ = StateType::CALL_STATUS_INCOMING; 1945 auto callManagerClientPtr = DelayedSingleton<OHOS::Telephony::CallManagerClient>::GetInstance(); 1946 EXPECT_NE(callManagerClientPtr, nullptr); 1947 DEVICE_MONITOR->hasHandleRingMute_ = false; 1948 keyEvent->keyCode_ = KeyEvent::KEYCODE_CALL; 1949 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 1950 } 1951 1952 /** 1953 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_06 1954 * @tc.desc: Test ring mute 1955 * @tc.type: FUNC 1956 * @tc.require: 1957 */ 1958 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_06, TestSize.Level1) 1959 { 1960 CALL_TEST_DEBUG; 1961 KeySubscriberHandler keySubscriberHandler; 1962 1963 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1964 ASSERT_NE(keyEvent, nullptr); 1965 keyEvent->keyCode_ = KeyEvent::KEYCODE_VOLUME_UP; 1966 1967 DEVICE_MONITOR->callState_ = StateType::CALL_STATUS_INCOMING; 1968 auto callManagerClientPtr = DelayedSingleton<OHOS::Telephony::CallManagerClient>::GetInstance(); 1969 EXPECT_NE(callManagerClientPtr, nullptr); 1970 DEVICE_MONITOR->hasHandleRingMute_ = true; 1971 keyEvent->keyCode_ = KeyEvent::KEYCODE_POWER; 1972 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 1973 } 1974 1975 /** 1976 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_07 1977 * @tc.desc: Test ring mute 1978 * @tc.type: FUNC 1979 * @tc.require: 1980 */ 1981 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_07, TestSize.Level1) 1982 { 1983 CALL_TEST_DEBUG; 1984 KeySubscriberHandler keySubscriberHandler; 1985 1986 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1987 ASSERT_NE(keyEvent, nullptr); 1988 keyEvent->keyCode_ = KeyEvent::KEYCODE_VOLUME_UP; 1989 1990 DEVICE_MONITOR->callState_ = StateType::CALL_STATUS_INCOMING; 1991 auto callManagerClientPtr = DelayedSingleton<OHOS::Telephony::CallManagerClient>::GetInstance(); 1992 EXPECT_NE(callManagerClientPtr, nullptr); 1993 DEVICE_MONITOR->hasHandleRingMute_ = true; 1994 keyEvent->keyCode_ = KeyEvent::KEYCODE_CAMERA; 1995 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 1996 } 1997 1998 /** 1999 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_08 2000 * @tc.desc: Test ring mute 2001 * @tc.type: FUNC 2002 * @tc.require: 2003 */ 2004 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_08, TestSize.Level1) 2005 { 2006 CALL_TEST_DEBUG; 2007 KeySubscriberHandler keySubscriberHandler; 2008 2009 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 2010 ASSERT_NE(keyEvent, nullptr); 2011 keyEvent->keyCode_ = KeyEvent::KEYCODE_VOLUME_DOWN; 2012 2013 DEVICE_MONITOR->callState_ = StateType::CALL_STATUS_INCOMING; 2014 std::shared_ptr<OHOS::Telephony::CallManagerClient> callManagerClientPtr = nullptr; 2015 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 2016 } 2017 2018 /** 2019 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_09 2020 * @tc.desc: Test ring mute 2021 * @tc.type: FUNC 2022 * @tc.require: 2023 */ 2024 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_09, TestSize.Level1) 2025 { 2026 CALL_TEST_DEBUG; 2027 KeySubscriberHandler keySubscriberHandler; 2028 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 2029 ASSERT_NE(keyEvent, nullptr); 2030 keyEvent->keyCode_ = KeyEvent::KEYCODE_VOLUME_DOWN; 2031 2032 DEVICE_MONITOR->callState_ = StateType::CALL_STATUS_INCOMING; 2033 std::shared_ptr<OHOS::Telephony::CallManagerClient> callManagerClientPtr; 2034 callManagerClientPtr = std::make_shared<OHOS::Telephony::CallManagerClient>(); 2035 EXPECT_NE(callManagerClientPtr, nullptr); 2036 DEVICE_MONITOR->hasHandleRingMute_ = false; 2037 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 2038 } 2039 2040 /** 2041 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_10 2042 * @tc.desc: Test ring mute 2043 * @tc.type: FUNC 2044 * @tc.require: 2045 */ 2046 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_10, TestSize.Level1) 2047 { 2048 CALL_TEST_DEBUG; 2049 KeySubscriberHandler keySubscriberHandler; 2050 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 2051 ASSERT_NE(keyEvent, nullptr); 2052 keyEvent->keyCode_ = KeyEvent::KEYCODE_VOLUME_DOWN; 2053 2054 DEVICE_MONITOR->callState_ = StateType::CALL_STATUS_INCOMING; 2055 std::shared_ptr<OHOS::Telephony::CallManagerClient> callManagerClientPtr; 2056 callManagerClientPtr = std::make_shared<OHOS::Telephony::CallManagerClient>(); 2057 EXPECT_NE(callManagerClientPtr, nullptr); 2058 DEVICE_MONITOR->hasHandleRingMute_ = true; 2059 keyEvent->keyCode_ = KeyEvent::KEYCODE_VOLUME_UP; 2060 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 2061 } 2062 2063 /** 2064 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_11 2065 * @tc.desc: Test ring mute 2066 * @tc.type: FUNC 2067 * @tc.require: 2068 */ 2069 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_11, TestSize.Level1) 2070 { 2071 CALL_TEST_DEBUG; 2072 KeySubscriberHandler keySubscriberHandler; 2073 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 2074 ASSERT_NE(keyEvent, nullptr); 2075 keyEvent->keyCode_ = KeyEvent::KEYCODE_VOLUME_DOWN; 2076 2077 DEVICE_MONITOR->callState_ = StateType::CALL_STATUS_INCOMING; 2078 std::shared_ptr<OHOS::Telephony::CallManagerClient> callManagerClientPtr; 2079 callManagerClientPtr = std::make_shared<OHOS::Telephony::CallManagerClient>(); 2080 EXPECT_NE(callManagerClientPtr, nullptr); 2081 DEVICE_MONITOR->hasHandleRingMute_ = true; 2082 keyEvent->keyCode_ = KeyEvent::KEYCODE_POWER; 2083 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 2084 } 2085 #endif // OHOS_BUILD_ENABLE_CALL_MANAGER 2086 2087 /** 2088 * @tc.name: KeySubscriberHandlerTest_AddKeyGestureSubscriber_01 2089 * @tc.desc: Test AddKeyGestureSubscriber 2090 * @tc.type: FUNC 2091 * @tc.require: 2092 */ 2093 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_AddKeyGestureSubscriber_01, TestSize.Level1) 2094 { 2095 CALL_TEST_DEBUG; 2096 KeySubscriberHandler handler; 2097 SessionPtr sess; 2098 std::shared_ptr<KeyOption> keyOption; 2099 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 2100 subscriber->timerId_ = -1; 2101 ASSERT_NO_FATAL_FAILURE(handler.AddKeyGestureSubscriber(subscriber, keyOption)); 2102 } 2103 2104 /** 2105 * @tc.name: KeySubscriberHandlerTest_AddKeyGestureSubscriber_02 2106 * @tc.desc: Test AddKeyGestureSubscriber 2107 * @tc.type: FUNC 2108 * @tc.require: 2109 */ 2110 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_AddKeyGestureSubscriber_02, TestSize.Level1) 2111 { 2112 CALL_TEST_DEBUG; 2113 KeySubscriberHandler handler; 2114 SessionPtr sess; 2115 std::shared_ptr<KeyOption> keyOption; 2116 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(3, sess, keyOption); 2117 subscriber->timerId_ = 1; 2118 2119 auto keyOption1 = std::make_shared<KeyOption>(); 2120 keyOption1->SetFinalKey(1); 2121 keyOption1->SetFinalKeyDown(true); 2122 auto keyOption2 = std::make_shared<KeyOption>(); 2123 keyOption2->SetFinalKey(1); 2124 keyOption2->SetFinalKeyDown(true); 2125 2126 std::list<std::shared_ptr<OHOS::MMI::KeySubscriberHandler::Subscriber>> subscribers; 2127 auto subscriber1 = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 2128 auto subscriber2 = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(2, sess, keyOption); 2129 subscribers.push_back(subscriber1); 2130 subscribers.push_back(subscriber2); 2131 handler.keyGestures_.insert({keyOption2, subscribers}); 2132 2133 for (auto &iter : handler.keyGestures_) { 2134 EXPECT_TRUE(handler.IsEqualKeyOption(keyOption1, iter.first)); 2135 } 2136 ASSERT_NO_FATAL_FAILURE(handler.AddKeyGestureSubscriber(subscriber, keyOption1)); 2137 } 2138 2139 /** 2140 * @tc.name: KeySubscriberHandlerTest_AddKeyGestureSubscriber_03 2141 * @tc.desc: Test AddKeyGestureSubscriber 2142 * @tc.type: FUNC 2143 * @tc.require: 2144 */ 2145 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_AddKeyGestureSubscriber_03, TestSize.Level1) 2146 { 2147 CALL_TEST_DEBUG; 2148 KeySubscriberHandler handler; 2149 SessionPtr sess; 2150 std::shared_ptr<KeyOption> keyOption; 2151 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(3, sess, keyOption); 2152 subscriber->timerId_ = 2; 2153 2154 auto keyOption1 = std::make_shared<KeyOption>(); 2155 keyOption1->SetFinalKey(2); 2156 keyOption1->SetFinalKeyDown(true); 2157 auto keyOption2 = std::make_shared<KeyOption>(); 2158 keyOption2->SetFinalKey(1); 2159 keyOption2->SetFinalKeyDown(false); 2160 2161 std::list<std::shared_ptr<OHOS::MMI::KeySubscriberHandler::Subscriber>> subscribers; 2162 auto subscriber1 = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 2163 auto subscriber2 = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(2, sess, keyOption); 2164 subscribers.push_back(subscriber1); 2165 subscribers.push_back(subscriber2); 2166 handler.keyGestures_.insert({keyOption2, subscribers}); 2167 2168 for (auto &iter : handler.keyGestures_) { 2169 EXPECT_FALSE(handler.IsEqualKeyOption(keyOption1, iter.first)); 2170 } 2171 ASSERT_NO_FATAL_FAILURE(handler.AddKeyGestureSubscriber(subscriber, keyOption1)); 2172 } 2173 2174 /** 2175 * @tc.name: KeySubscriberHandlerTest_RemoveKeyGestureSubscriber_01 2176 * @tc.desc: Test RemoveKeyGestureSubscriber 2177 * @tc.type: FUNC 2178 * @tc.require: 2179 */ 2180 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_RemoveKeyGestureSubscriber_01, TestSize.Level1) 2181 { 2182 CALL_TEST_DEBUG; 2183 KeySubscriberHandler handler; 2184 SessionPtr sess = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 2185 EXPECT_NE(sess, nullptr); 2186 2187 auto keyOption1 = std::make_shared<KeyOption>(); 2188 keyOption1->SetFinalKey(2); 2189 keyOption1->SetFinalKeyDown(true); 2190 auto keyOption2 = std::make_shared<KeyOption>(); 2191 keyOption2->SetFinalKey(1); 2192 keyOption2->SetFinalKeyDown(false); 2193 2194 std::list<std::shared_ptr<OHOS::MMI::KeySubscriberHandler::Subscriber>> subscribers; 2195 std::shared_ptr<KeyOption> keyOption; 2196 auto subscriber1 = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 2197 auto subscriber2 = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(2, sess, keyOption); 2198 subscribers.push_back(subscriber1); 2199 subscribers.push_back(subscriber2); 2200 handler.keyGestures_.insert({keyOption2, subscribers}); 2201 2202 int32_t subscribeId = 3; 2203 for (auto &iter : handler.keyGestures_) { 2204 for (auto innerIter = iter.second.begin(); innerIter != iter.second.end(); ++innerIter) { 2205 auto subscriber = *innerIter; 2206 EXPECT_TRUE(subscriber->id_ != subscribeId); 2207 EXPECT_FALSE(subscriber->sess_ != sess); 2208 } 2209 int32_t ret = handler.RemoveKeyGestureSubscriber(sess, subscribeId); 2210 EXPECT_EQ(ret, RET_ERR); 2211 } 2212 } 2213 2214 /** 2215 * @tc.name: InputWindowsManagerTest_UnsubscribeKeyEvent_01 2216 * @tc.desc: Test UnsubscribeKeyEvent 2217 * @tc.type: FUNC 2218 * @tc.require: 2219 */ 2220 HWTEST_F(KeySubscriberHandlerTest, InputWindowsManagerTest_UnsubscribeKeyEvent_01, TestSize.Level1) 2221 { 2222 CALL_TEST_DEBUG; 2223 KeySubscriberHandler keySubscriberHandler; 2224 SessionPtr sess = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 2225 EXPECT_NE(sess, nullptr); 2226 int32_t subscribeId = 2; 2227 int32_t ret1 = keySubscriberHandler.RemoveSubscriber(sess, subscribeId, true); 2228 EXPECT_EQ(ret1, RET_ERR); 2229 int32_t ret2 = keySubscriberHandler.UnsubscribeKeyEvent(sess, subscribeId); 2230 EXPECT_EQ(ret2, RET_ERR); 2231 } 2232 2233 /** 2234 * @tc.name: KeySubscriberHandlerTest_NotifySubscriber_01 2235 * @tc.desc: Test NotifySubscriber 2236 * @tc.type: FUNC 2237 * @tc.require: 2238 */ 2239 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifySubscriber_01, TestSize.Level1) 2240 { 2241 CALL_TEST_DEBUG; 2242 KeySubscriberHandler handler; 2243 SessionPtr sess = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 2244 EXPECT_NE(sess, nullptr); 2245 std::shared_ptr<KeyOption> keyOption; 2246 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 2247 EXPECT_NE(keyEvent, nullptr); 2248 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 2249 EXPECT_NE(subscriber, nullptr); 2250 keyEvent->keyCode_ = KeyEvent::KEYCODE_POWER; 2251 ASSERT_NO_FATAL_FAILURE(handler.NotifySubscriber(keyEvent, subscriber)); 2252 } 2253 2254 /** 2255 * @tc.name: KeySubscriberHandlerTest_NotifySubscriber_02 2256 * @tc.desc: Test NotifySubscriber 2257 * @tc.type: FUNC 2258 * @tc.require: 2259 */ 2260 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifySubscriber_02, TestSize.Level1) 2261 { 2262 CALL_TEST_DEBUG; 2263 KeySubscriberHandler handler; 2264 SessionPtr sess = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 2265 EXPECT_NE(sess, nullptr); 2266 std::shared_ptr<KeyOption> keyOption; 2267 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 2268 EXPECT_NE(keyEvent, nullptr); 2269 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 2270 EXPECT_NE(subscriber, nullptr); 2271 keyEvent->keyCode_ = KeyEvent::KEYCODE_VOLUME_UP; 2272 ASSERT_NO_FATAL_FAILURE(handler.NotifySubscriber(keyEvent, subscriber)); 2273 } 2274 2275 /** 2276 * @tc.name: KeySubscriberHandlerTest_OnSubscribeKeyEvent_004 2277 * @tc.desc: Test the funcation OnSubscribeKeyEvent 2278 * @tc.type: FUNC 2279 * @tc.require: 2280 */ 2281 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_OnSubscribeKeyEvent_004, TestSize.Level1) 2282 { 2283 CALL_DEBUG_ENTER; 2284 KeySubscriberHandler handler; 2285 KeyEvent::KeyItem item; 2286 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 2287 ASSERT_NE(keyEvent, nullptr); 2288 handler.enableCombineKey_ = false; 2289 keyEvent->SetKeyCode(KeyEvent::KEY_ACTION_UP); 2290 item.SetKeyCode(KeyEvent::KEYCODE_O); 2291 keyEvent->AddKeyItem(item); 2292 item.SetKeyCode(KeyEvent::KEYCODE_P); 2293 keyEvent->AddKeyItem(item); 2294 ASSERT_FALSE(handler.OnSubscribeKeyEvent(keyEvent)); 2295 handler.enableCombineKey_ = true; 2296 handler.hasEventExecuting_ = true; 2297 handler.keyEvent_ = KeyEvent::Create(); 2298 ASSERT_NE(handler.keyEvent_, nullptr); 2299 handler.keyEvent_->SetKeyCode(KeyEvent::KEY_ACTION_UP); 2300 handler.keyEvent_->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 2301 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 2302 item.SetKeyCode(KeyEvent::KEYCODE_O); 2303 handler.keyEvent_->AddKeyItem(item); 2304 item.SetKeyCode(KeyEvent::KEYCODE_P); 2305 handler.keyEvent_->AddKeyItem(item); 2306 ASSERT_TRUE(handler.OnSubscribeKeyEvent(keyEvent)); 2307 handler.hasEventExecuting_ = false; 2308 handler.needSkipPowerKeyUp_ = true; 2309 keyEvent->SetKeyCode(KeyEvent::KEY_ACTION_CANCEL); 2310 ASSERT_FALSE(handler.OnSubscribeKeyEvent(keyEvent)); 2311 } 2312 2313 /** 2314 * @tc.name: KeySubscriberHandlerTest_NotifySubscriber_003 2315 * @tc.desc: Test the funcation NotifySubscriber 2316 * @tc.type: FUNC 2317 * @tc.require: 2318 */ 2319 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifySubscriber_003, TestSize.Level1) 2320 { 2321 CALL_TEST_DEBUG; 2322 KeySubscriberHandler handler; 2323 SessionPtr sess; 2324 std::shared_ptr<KeyOption> keyOption; 2325 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 2326 ASSERT_NE(keyEvent, nullptr); 2327 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 2328 KeyEvent::KeyItem item; 2329 item.SetKeyCode(KeyEvent::KEYCODE_POWER); 2330 keyEvent->AddKeyItem(item); 2331 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 2332 ASSERT_NO_FATAL_FAILURE(handler.NotifySubscriber(keyEvent, subscriber)); 2333 item.SetKeyCode(KeyEvent::KEYCODE_CAMERA); 2334 keyEvent->AddKeyItem(item); 2335 keyEvent->SetKeyCode(KeyEvent::KEYCODE_CAMERA); 2336 ASSERT_NO_FATAL_FAILURE(handler.NotifySubscriber(keyEvent, subscriber)); 2337 } 2338 2339 /** 2340 * @tc.name: KeySubscriberHandlerTest_NotifySubscriber_004 2341 * @tc.desc: Test NotifySubscriber 2342 * @tc.type: FUNC 2343 * @tc.require: 2344 */ 2345 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifySubscriber_004, TestSize.Level1) 2346 { 2347 CALL_TEST_DEBUG; 2348 KeySubscriberHandler handler; 2349 SessionPtr sess; 2350 std::shared_ptr<KeyOption> keyOption; 2351 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 2352 ASSERT_NE(keyEvent, nullptr); 2353 2354 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 2355 ASSERT_NE(subscriber, nullptr); 2356 2357 keyEvent->keyCode_ = KeyEvent::KEYCODE_POWER; 2358 ASSERT_NO_FATAL_FAILURE(handler.NotifySubscriber(keyEvent, subscriber)); 2359 } 2360 2361 /** 2362 * @tc.name: KeySubscriberHandlerTest_NotifySubscriber_005 2363 * @tc.desc: Test NotifySubscriber 2364 * @tc.type: FUNC 2365 * @tc.require: 2366 */ 2367 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifySubscriber_005, TestSize.Level1) 2368 { 2369 CALL_TEST_DEBUG; 2370 KeySubscriberHandler handler; 2371 SessionPtr sess; 2372 std::shared_ptr<KeyOption> keyOption; 2373 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 2374 ASSERT_NE(keyEvent, nullptr); 2375 2376 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 2377 ASSERT_NE(subscriber, nullptr); 2378 keyEvent->keyCode_ = KeyEvent::KEYCODE_CAMERA; 2379 EXPECT_TRUE(EventLogHelper::IsBetaVersion()); 2380 EXPECT_FALSE(keyEvent->HasFlag(InputEvent::EVENT_FLAG_PRIVACY_MODE)); 2381 2382 NetPacket pkt(MmiMessageId::ON_SUBSCRIBE_KEY); 2383 EXPECT_FALSE(pkt.ChkRWError()); 2384 ASSERT_NO_FATAL_FAILURE(handler.NotifySubscriber(keyEvent, subscriber)); 2385 } 2386 2387 /** 2388 * @tc.name: KeySubscriberHandlerTest_HandleKeyDown_003 2389 * @tc.desc: Test the funcation HandleKeyDown 2390 * @tc.type: FUNC 2391 * @tc.require: 2392 */ 2393 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleKeyDown_003, TestSize.Level1) 2394 { 2395 CALL_DEBUG_ENTER; 2396 KeySubscriberHandler handler; 2397 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 2398 ASSERT_NE(keyEvent, nullptr); 2399 auto keyOption = std::make_shared<KeyOption>(); 2400 keyOption->isFinalKeyDown_ = true; 2401 keyEvent->keyCode_ = 1; 2402 SessionPtr sess; 2403 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 2404 std::list<std::shared_ptr<OHOS::MMI::KeySubscriberHandler::Subscriber>> subscribers; 2405 subscribers.push_back(subscriber); 2406 handler.subscriberMap_.insert(std::make_pair(keyOption, subscribers)); 2407 keyOption->finalKey_ = 5; 2408 bool ret = handler.HandleKeyDown(keyEvent); 2409 ASSERT_FALSE(ret); 2410 keyOption->finalKey_ = 1; 2411 subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 2412 subscribers.push_back(subscriber); 2413 handler.subscriberMap_.insert(std::make_pair(keyOption, subscribers)); 2414 KeyEvent::KeyItem item; 2415 item.SetKeyCode(KeyEvent::KEYCODE_CAMERA); 2416 keyEvent->AddKeyItem(item); 2417 keyEvent->SetKeyCode(KeyEvent::KEYCODE_CAMERA); 2418 ret = handler.HandleKeyDown(keyEvent); 2419 ASSERT_FALSE(ret); 2420 } 2421 2422 /** 2423 * @tc.name: KeySubscriberHandlerTest_SubscriberNotifyNap_002 2424 * @tc.desc: Test the funcation SubscriberNotifyNap 2425 * @tc.type: FUNC 2426 * @tc.require: 2427 */ 2428 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_SubscriberNotifyNap_002, TestSize.Level1) 2429 { 2430 CALL_TEST_DEBUG; 2431 KeySubscriberHandler handler; 2432 SessionPtr sess; 2433 std::shared_ptr<KeyOption> keyOption; 2434 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 2435 NapProcess napProcess; 2436 napProcess.instance_->napClientPid_ = REMOVE_OBSERVER; 2437 ASSERT_NO_FATAL_FAILURE(handler.SubscriberNotifyNap(subscriber)); 2438 napProcess.instance_->napClientPid_ = UNOBSERVED; 2439 ASSERT_NO_FATAL_FAILURE(handler.SubscriberNotifyNap(subscriber)); 2440 napProcess.instance_->napClientPid_ = 10; 2441 ASSERT_NO_FATAL_FAILURE(handler.SubscriberNotifyNap(subscriber)); 2442 } 2443 2444 /** 2445 * @tc.name: KeySubscriberHandlerTest_SubscriberNotifyNap_003 2446 * @tc.desc: Test the funcation SubscriberNotifyNap 2447 * @tc.type: FUNC 2448 * @tc.require: 2449 */ 2450 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_SubscriberNotifyNap_003, TestSize.Level1) 2451 { 2452 CALL_TEST_DEBUG; 2453 KeySubscriberHandler handler; 2454 SessionPtr sess; 2455 std::shared_ptr<KeyOption> keyOption; 2456 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 2457 ASSERT_NE(subscriber, nullptr); 2458 2459 NapProcess napProcess; 2460 napProcess.instance_->napClientPid_ = ACTIVE_EVENT; 2461 OHOS::MMI::NapProcess::NapStatusData napData; 2462 napData.pid = 2; 2463 napData.uid = 3; 2464 napData.bundleName = "programName"; 2465 EXPECT_FALSE(napProcess.IsNeedNotify(napData)); 2466 ASSERT_NO_FATAL_FAILURE(handler.SubscriberNotifyNap(subscriber)); 2467 } 2468 2469 /** 2470 * @tc.name: KeySubscriberHandlerTest_SubscribeKeyEvent_003 2471 * @tc.desc: Test subscribe keyEvent 2472 * @tc.type: FUNC 2473 * @tc.require: 2474 */ 2475 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_SubscribeKeyEvent_003, TestSize.Level1) 2476 { 2477 CALL_TEST_DEBUG; 2478 KeySubscriberHandler handler; 2479 int32_t subscribeId = 1; 2480 SessionPtr sess = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 2481 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 2482 std::set<int32_t> preKeys = { 2017, 2018, 2019, 2072, 2046 }; 2483 keyOption->SetPreKeys(preKeys); 2484 EXPECT_EQ(handler.SubscribeKeyEvent(sess, subscribeId, keyOption), RET_ERR); 2485 } 2486 2487 /** 2488 * @tc.name: KeySubscriberHandlerTest_SubscribeKeyEvent_004 2489 * @tc.desc: Test subscribe keyEvent 2490 * @tc.type: FUNC 2491 * @tc.require: 2492 */ 2493 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_SubscribeKeyEvent_004, TestSize.Level1) 2494 { 2495 CALL_TEST_DEBUG; 2496 KeySubscriberHandler handler; 2497 int32_t subscribeId = 1; 2498 SessionPtr sess = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 2499 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 2500 keyOption->SetFinalKey(2072); 2501 keyOption->SetFinalKeyDown(true); 2502 keyOption->SetFinalKeyDownDuration(100); 2503 EXPECT_NE(handler.SubscribeKeyEvent(sess, subscribeId, keyOption), RET_OK); 2504 } 2505 2506 /** 2507 * @tc.name: KeySubscriberHandlerTest_RemoveKeyGestureSubscriber 2508 * @tc.desc: Test RemoveKeyGestureSubscriber 2509 * @tc.type: FUNC 2510 * @tc.require: 2511 */ 2512 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_RemoveKeyGestureSubscriber, TestSize.Level1) 2513 { 2514 CALL_TEST_DEBUG; 2515 KeySubscriberHandler handler; 2516 int32_t subscribeId = 1; 2517 SessionPtr sess = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 2518 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 2519 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 2520 std::make_shared<KeySubscriberHandler::Subscriber>(subscribeId, sess, keyOption); 2521 std::list<std::shared_ptr<KeySubscriberHandler::Subscriber>> listSub; 2522 listSub.push_back(subscriber); 2523 subscribeId = 2; 2524 handler.keyGestures_.insert(std::make_pair(keyOption, listSub)); 2525 EXPECT_EQ(handler.RemoveKeyGestureSubscriber(sess, subscribeId), RET_ERR); 2526 } 2527 2528 /** 2529 * @tc.name: KeySubscriberHandlerTest_RemoveKeyGestureSubscriber_001 2530 * @tc.desc: Test RemoveKeyGestureSubscriber 2531 * @tc.type: FUNC 2532 * @tc.require: 2533 */ 2534 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_RemoveKeyGestureSubscriber_001, TestSize.Level1) 2535 { 2536 CALL_TEST_DEBUG; 2537 KeySubscriberHandler handler; 2538 int32_t subscribeId = 1; 2539 SessionPtr sess = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 2540 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 2541 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 2542 std::make_shared<KeySubscriberHandler::Subscriber>(subscribeId, sess, keyOption); 2543 std::list<std::shared_ptr<KeySubscriberHandler::Subscriber>> listSub; 2544 listSub.push_back(subscriber); 2545 SessionPtr session = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 2546 handler.keyGestures_.insert(std::make_pair(keyOption, listSub)); 2547 EXPECT_EQ(handler.RemoveKeyGestureSubscriber(session, subscribeId), RET_ERR); 2548 } 2549 2550 /** 2551 * @tc.name: KeySubscriberHandlerTest_RemoveKeyGestureSubscriber_002 2552 * @tc.desc: Test RemoveKeyGestureSubscriber 2553 * @tc.type: FUNC 2554 * @tc.require: 2555 */ 2556 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_RemoveKeyGestureSubscriber_002, TestSize.Level1) 2557 { 2558 CALL_TEST_DEBUG; 2559 KeySubscriberHandler handler; 2560 int32_t subscribeId = 1; 2561 SessionPtr sess = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 2562 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 2563 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 2564 std::make_shared<KeySubscriberHandler::Subscriber>(subscribeId, sess, keyOption); 2565 std::list<std::shared_ptr<KeySubscriberHandler::Subscriber>> listSub; 2566 listSub.push_back(subscriber); 2567 handler.keyGestures_.insert(std::make_pair(keyOption, listSub)); 2568 EXPECT_EQ(handler.RemoveKeyGestureSubscriber(sess, subscribeId), RET_OK); 2569 } 2570 2571 /** 2572 * @tc.name: KeySubscriberHandlerTest_OnSessionDelete_002 2573 * @tc.desc: Test OnSessionDelete 2574 * @tc.type: FUNC 2575 * @tc.require: 2576 */ 2577 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_OnSessionDelete_002, TestSize.Level1) 2578 { 2579 CALL_TEST_DEBUG; 2580 KeySubscriberHandler handler; 2581 int32_t subscribeId = 1; 2582 SessionPtr sess = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 2583 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 2584 2585 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 2586 std::make_shared<KeySubscriberHandler::Subscriber>(subscribeId, sess, keyOption); 2587 std::list<std::shared_ptr<KeySubscriberHandler::Subscriber>> listSub; 2588 listSub.push_back(subscriber); 2589 2590 SessionPtr session = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 2591 std::shared_ptr<KeySubscriberHandler::Subscriber> keySubscriber = 2592 std::make_shared<KeySubscriberHandler::Subscriber>(subscribeId, session, keyOption); 2593 listSub.push_back(keySubscriber); 2594 handler.keyGestures_.insert(std::make_pair(keyOption, listSub)); 2595 EXPECT_NO_FATAL_FAILURE(handler.OnSessionDelete(session)); 2596 } 2597 2598 /** 2599 * @tc.name: KeySubscriberHandlerTest_OnSessionDelete_003 2600 * @tc.desc: Test OnSessionDelete 2601 * @tc.type: FUNC 2602 * @tc.require: 2603 */ 2604 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_OnSessionDelete_003, TestSize.Level1) 2605 { 2606 CALL_TEST_DEBUG; 2607 KeySubscriberHandler handler; 2608 int32_t subscribeId = 1; 2609 SessionPtr sess = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 2610 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 2611 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 2612 std::make_shared<KeySubscriberHandler::Subscriber>(subscribeId, sess, keyOption); 2613 std::list<std::shared_ptr<KeySubscriberHandler::Subscriber>> listSub; 2614 handler.keyGestures_.insert(std::make_pair(keyOption, listSub)); 2615 EXPECT_NO_FATAL_FAILURE(handler.OnSessionDelete(sess)); 2616 } 2617 2618 /** 2619 * @tc.name: KeySubscriberHandlerTest_HandleKeyUpWithDelay_03 2620 * @tc.desc: Test HandleKeyUpWithDelay 2621 * @tc.type: FUNC 2622 * @tc.require: 2623 */ 2624 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleKeyUpWithDelay_03, TestSize.Level1) 2625 { 2626 CALL_TEST_DEBUG; 2627 KeySubscriberHandler handler; 2628 int32_t subscribeId = 1; 2629 SessionPtr sess = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 2630 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 2631 keyOption->SetFinalKeyUpDelay(-1); 2632 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 2633 std::make_shared<KeySubscriberHandler::Subscriber>(subscribeId, sess, keyOption); 2634 std::shared_ptr<KeyEvent> keyEvent = nullptr; 2635 EXPECT_NO_FATAL_FAILURE(handler.HandleKeyUpWithDelay(keyEvent, subscriber)); 2636 } 2637 2638 /** 2639 * @tc.name: KeySubscriberHandlerTest_HandleKeyUpWithDelay_04 2640 * @tc.desc: Test HandleKeyUpWithDelay 2641 * @tc.type: FUNC 2642 * @tc.require: 2643 */ 2644 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleKeyUpWithDelay_04, TestSize.Level1) 2645 { 2646 CALL_TEST_DEBUG; 2647 KeySubscriberHandler handler; 2648 int32_t subscribeId = 1; 2649 SessionPtr sess = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 2650 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 2651 keyOption->SetFinalKeyUpDelay(100); 2652 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 2653 std::make_shared<KeySubscriberHandler::Subscriber>(subscribeId, sess, keyOption); 2654 std::shared_ptr<KeyEvent> keyEvent = nullptr; 2655 EXPECT_NO_FATAL_FAILURE(handler.HandleKeyUpWithDelay(keyEvent, subscriber)); 2656 } 2657 2658 /** 2659 * @tc.name: KeySubscriberHandlerTest_DumpSubscriber 2660 * @tc.desc: Test DumpSubscriber 2661 * @tc.type: FUNC 2662 * @tc.require: 2663 */ 2664 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_DumpSubscriber, TestSize.Level1) 2665 { 2666 CALL_TEST_DEBUG; 2667 KeySubscriberHandler handler; 2668 int32_t subscribeId = 1; 2669 SessionPtr sess = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 2670 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 2671 keyOption->SetFinalKeyUpDelay(100); 2672 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 2673 std::make_shared<KeySubscriberHandler::Subscriber>(subscribeId, sess, keyOption); 2674 int32_t fd = 100; 2675 EXPECT_NO_FATAL_FAILURE(handler.DumpSubscriber(fd, subscriber)); 2676 2677 std::shared_ptr<KeyOption> option = std::make_shared<KeyOption>(); 2678 std::set<int32_t> preKeys = { 2020, 2021 }; 2679 option->SetPreKeys(preKeys); 2680 subscriber = std::make_shared<KeySubscriberHandler::Subscriber>(subscribeId, sess, option); 2681 EXPECT_NO_FATAL_FAILURE(handler.DumpSubscriber(fd, subscriber)); 2682 } 2683 2684 /** 2685 * @tc.name: KeySubscriberHandlerTest_InitDataShareListener 2686 * @tc.desc: Test InitDataShareListener 2687 * @tc.type: FUNC 2688 * @tc.require: 2689 */ 2690 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_InitDataShareListener, TestSize.Level1) 2691 { 2692 CALL_TEST_DEBUG; 2693 KeySubscriberHandler handler; 2694 EXPECT_NO_FATAL_FAILURE(handler.InitDataShareListener()); 2695 } 2696 2697 #ifdef OHOS_BUILD_ENABLE_CALL_MANAGER 2698 /** 2699 * @tc.name: KeySubscriberHandlerTest_RejectCallProcess 2700 * @tc.desc: Test RejectCallProcess 2701 * @tc.type: FUNC 2702 * @tc.require: 2703 */ 2704 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_RejectCallProcess, TestSize.Level1) 2705 { 2706 CALL_TEST_DEBUG; 2707 KeySubscriberHandler handler; 2708 EXPECT_NO_FATAL_FAILURE(handler.RejectCallProcess()); 2709 } 2710 2711 /** 2712 * @tc.name: KeySubscriberHandlerTest_HangUpCallProcess 2713 * @tc.desc: Test HangUpCallProcess 2714 * @tc.type: FUNC 2715 * @tc.require: 2716 */ 2717 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HangUpCallProcess, TestSize.Level1) 2718 { 2719 CALL_TEST_DEBUG; 2720 KeySubscriberHandler handler; 2721 EXPECT_NO_FATAL_FAILURE(handler.HangUpCallProcess()); 2722 } 2723 2724 /** 2725 * @tc.name: KeySubscriberHandlerTest_HandleCallEnded 2726 * @tc.desc: Test HandleCallEnded 2727 * @tc.type: FUNC 2728 * @tc.require: 2729 */ 2730 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleCallEnded, TestSize.Level1) 2731 { 2732 CALL_TEST_DEBUG; 2733 KeySubscriberHandler handler; 2734 auto keyEvent = KeyEvent::Create(); 2735 bool ret = false; 2736 handler.callBahaviorState_ = false; 2737 ret = handler.HandleCallEnded(keyEvent); 2738 ASSERT_FALSE(ret); 2739 handler.callBahaviorState_ = true; 2740 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_CANCEL); 2741 keyEvent->SetKeyCode(KeyEvent::KEYCODE_CAMERA); 2742 ret = handler.HandleCallEnded(keyEvent); 2743 ASSERT_FALSE(ret); 2744 2745 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 2746 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 2747 ret = handler.HandleCallEnded(keyEvent); 2748 ASSERT_FALSE(ret); 2749 2750 DISPLAY_MONITOR->SetScreenStatus(EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_ON); 2751 DEVICE_MONITOR->callState_ = StateType::CALL_STATUS_DIALING; 2752 ret = handler.HandleCallEnded(keyEvent); 2753 ASSERT_FALSE(ret); 2754 2755 DEVICE_MONITOR->callState_ = CALL_STATUS_INCOMING; 2756 ret = handler.HandleCallEnded(keyEvent); 2757 ASSERT_FALSE(ret); 2758 2759 DEVICE_MONITOR->callState_ = 10; 2760 ret = handler.HandleCallEnded(keyEvent); 2761 ASSERT_FALSE(ret); 2762 } 2763 2764 /** 2765 * @tc.name: KeySubscriberHandlerTest_RemoveSubscriberTimer 2766 * @tc.desc: Test RemoveSubscriberTimer 2767 * @tc.type: FUNC 2768 * @tc.require: 2769 */ 2770 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_RemoveSubscriberTimer, TestSize.Level1) 2771 { 2772 CALL_TEST_DEBUG; 2773 KeySubscriberHandler handler; 2774 auto keyEvent = KeyEvent::Create(); 2775 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 2776 for (auto i = 0; i < 5; i++) { 2777 KeyEvent::KeyItem keyItem; 2778 keyItem.SetKeyCode(KeyEvent::KEYCODE_POWER); 2779 keyItem.SetPressed(true); 2780 keyEvent->keys_.push_back(keyItem); 2781 } 2782 EXPECT_NO_FATAL_FAILURE(handler.RemoveSubscriberTimer(keyEvent)); 2783 } 2784 #endif // OHOS_BUILD_ENABLE_CALL_MANAGER 2785 2786 /** 2787 * @tc.name: KeySubscriberHandlerTest_RemoveSubscriberKeyUpTimer 2788 * @tc.desc: Test RemoveSubscriberKeyUpTimer 2789 * @tc.type: FUNC 2790 * @tc.require: 2791 */ 2792 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_RemoveSubscriberKeyUpTimer, TestSize.Level1) 2793 { 2794 CALL_TEST_DEBUG; 2795 KeySubscriberHandler handler; 2796 auto keyEvent = KeyEvent::Create(); 2797 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 2798 EXPECT_NO_FATAL_FAILURE(handler.RemoveSubscriberKeyUpTimer(KeyEvent::KEYCODE_POWER)); 2799 } 2800 2801 /** 2802 * @tc.name: KeySubscriberHandlerTest_HandleKeyEvent_002 2803 * @tc.desc: Test HandleKeyEvent 2804 * @tc.type: FUNC 2805 * @tc.require:nhj 2806 */ 2807 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleKeyEvent_002, TestSize.Level1) 2808 { 2809 CALL_DEBUG_ENTER; 2810 KeySubscriberHandler handler; 2811 KeyEvent::KeyItem item; 2812 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 2813 ASSERT_NE(keyEvent, nullptr); 2814 handler.enableCombineKey_ = false; 2815 keyEvent->SetKeyCode(KeyEvent::KEYCODE_BRIGHTNESS_DOWN); 2816 item.SetKeyCode(KeyEvent::KEYCODE_A); 2817 keyEvent->AddKeyItem(item); 2818 item.SetKeyCode(KeyEvent::KEYCODE_B); 2819 keyEvent->AddKeyItem(item); 2820 EXPECT_FALSE(handler.OnSubscribeKeyEvent(keyEvent)); 2821 ASSERT_NO_FATAL_FAILURE(handler.HandleKeyEvent(keyEvent)); 2822 2823 handler.enableCombineKey_ = true; 2824 handler.hasEventExecuting_ = true; 2825 handler.keyEvent_ = KeyEvent::Create(); 2826 ASSERT_NE(handler.keyEvent_, nullptr); 2827 DISPLAY_MONITOR->screenStatus_ = EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_OFF; 2828 handler.keyEvent_->SetKeyCode(KeyEvent::KEYCODE_BRIGHTNESS_DOWN); 2829 handler.keyEvent_->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 2830 keyEvent->SetFourceMonitorFlag(true); 2831 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 2832 item.SetKeyCode(KeyEvent::KEYCODE_A); 2833 handler.keyEvent_->AddKeyItem(item); 2834 item.SetKeyCode(KeyEvent::KEYCODE_B); 2835 handler.keyEvent_->AddKeyItem(item); 2836 EXPECT_TRUE(handler.OnSubscribeKeyEvent(keyEvent)); 2837 EXPECT_FALSE(keyEvent->HasFlag(InputEvent::EVENT_FLAG_PRIVACY_MODE)); 2838 ASSERT_NO_FATAL_FAILURE(handler.HandleKeyEvent(keyEvent)); 2839 } 2840 2841 /** 2842 * @tc.name: KeySubscriberHandlerTest_AddKeyGestureSubscriber_04 2843 * @tc.desc: Test AddKeyGestureSubscriber 2844 * @tc.type: FUNC 2845 * @tc.require: 2846 */ 2847 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_AddKeyGestureSubscriber_04, TestSize.Level1) 2848 { 2849 CALL_TEST_DEBUG; 2850 KeySubscriberHandler handler; 2851 SessionPtr sess; 2852 std::shared_ptr<KeyOption> keyOption; 2853 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(3, sess, keyOption); 2854 subscriber->timerId_ = 1; 2855 2856 auto keyOption1 = std::make_shared<KeyOption>(); 2857 keyOption1->SetFinalKey(1); 2858 keyOption1->SetFinalKeyDown(false); 2859 auto keyOption2 = std::make_shared<KeyOption>(); 2860 keyOption2->SetFinalKey(1); 2861 keyOption2->SetFinalKeyDown(true); 2862 2863 std::list<std::shared_ptr<OHOS::MMI::KeySubscriberHandler::Subscriber>> subscribers; 2864 auto subscriber1 = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 2865 auto subscriber2 = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(2, sess, keyOption); 2866 subscribers.push_back(subscriber1); 2867 subscribers.push_back(subscriber2); 2868 handler.keyGestures_.insert({keyOption2, subscribers}); 2869 2870 for (auto &iter : handler.keyGestures_) { 2871 EXPECT_FALSE(handler.IsEqualKeyOption(keyOption1, iter.first)); 2872 } 2873 EXPECT_EQ(handler.AddKeyGestureSubscriber(subscriber, keyOption), RET_ERR); 2874 } 2875 2876 /** 2877 * @tc.name: KeySubscriberHandlerTest_AddKeyGestureSubscriber_05 2878 * @tc.desc: Test AddKeyGestureSubscriber 2879 * @tc.type: FUNC 2880 * @tc.require: 2881 */ 2882 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_AddKeyGestureSubscriber_05, TestSize.Level1) 2883 { 2884 CALL_TEST_DEBUG; 2885 KeySubscriberHandler handler; 2886 SessionPtr sess; 2887 std::shared_ptr<KeyOption> keyOption; 2888 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 2889 subscriber->timerId_ = -1; 2890 ASSERT_NO_FATAL_FAILURE(handler.AddKeyGestureSubscriber(subscriber, keyOption)); 2891 EXPECT_EQ(handler.AddKeyGestureSubscriber(subscriber, keyOption), RET_ERR); 2892 } 2893 2894 /** 2895 * @tc.name: KeySubscriberHandlerTest_SubscribeHotkey 2896 * @tc.desc: Test SubscribeHotkey 2897 * @tc.type: FUNC 2898 * @tc.require: 2899 */ 2900 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_SubscribeHotkey, TestSize.Level1) 2901 { 2902 CALL_DEBUG_ENTER; 2903 KeySubscriberHandler handler; 2904 int32_t subscribeId = 1; 2905 SessionPtr sess = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 2906 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 2907 std::set<int32_t> preKeys; 2908 preKeys.insert(1); 2909 keyOption->SetPreKeys(preKeys); 2910 uint32_t preKeySize = keyOption->GetPreKeys().size(); 2911 ASSERT_NE(preKeySize, MAX_PRE_KEY_COUNT); 2912 ASSERT_NE(handler.SubscribeHotkey(sess, subscribeId, keyOption), RET_OK); 2913 preKeys.insert(2); 2914 preKeys.insert(3); 2915 preKeys.insert(4); 2916 preKeys.insert(5); 2917 preKeys.insert(6); 2918 keyOption->SetPreKeys(preKeys); 2919 ASSERT_EQ(handler.SubscribeHotkey(sess, subscribeId, keyOption), RET_ERR); 2920 } 2921 2922 /** 2923 * @tc.name: KeySubscriberHandlerTest_UnsubscribeHotkey 2924 * @tc.desc: Test UnsubscribeHotkey 2925 * @tc.type: FUNC 2926 * @tc.require: 2927 */ 2928 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_UnsubscribeHotkey, TestSize.Level1) 2929 { 2930 CALL_DEBUG_ENTER; 2931 KeySubscriberHandler handler; 2932 int32_t subscribeId = 1; 2933 int32_t id = 1; 2934 std::list<std::shared_ptr<KeySubscriberHandler::Subscriber>> subscriberList; 2935 SessionPtr session = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 2936 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 2937 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 2938 std::make_shared<KeySubscriberHandler::Subscriber>(id, session, keyOption); 2939 subscriberList.push_back(subscriber); 2940 handler.subscriberMap_.insert(std::make_pair(keyOption, subscriberList)); 2941 ASSERT_NE(handler.UnsubscribeHotkey(session, subscribeId), RET_ERR); 2942 } 2943 2944 #ifdef OHOS_BUILD_ENABLE_CALL_MANAGER 2945 /** 2946 * @tc.name: KeySubscriberHandlerTest_HandleCallEnded 2947 * @tc.desc: Test HandleCallEnded 2948 * @tc.type: FUNC 2949 * @tc.require: 2950 */ 2951 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleCallEnded001, TestSize.Level1) 2952 { 2953 CALL_TEST_DEBUG; 2954 KeySubscriberHandler handler; 2955 auto keyEvent = KeyEvent::Create(); 2956 bool ret = false; 2957 handler.callBahaviorState_ = false; 2958 ret = handler.HandleCallEnded(keyEvent); 2959 ASSERT_FALSE(ret); 2960 handler.callBahaviorState_ = true; 2961 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_UP); 2962 keyEvent->SetKeyCode(KeyEvent::KEYCODE_CUSTOM1); 2963 ret = handler.HandleCallEnded(keyEvent); 2964 ASSERT_FALSE(ret); 2965 2966 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 2967 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 2968 ret = handler.HandleCallEnded(keyEvent); 2969 ASSERT_FALSE(ret); 2970 2971 DISPLAY_MONITOR->SetScreenStatus(EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_OFF); 2972 DEVICE_MONITOR->callState_ = StateType::CALL_STATUS_DIALING; 2973 ret = handler.HandleCallEnded(keyEvent); 2974 ASSERT_FALSE(ret); 2975 2976 DEVICE_MONITOR->callState_ = CALL_STATUS_INCOMING; 2977 ret = handler.HandleCallEnded(keyEvent); 2978 ASSERT_FALSE(ret); 2979 2980 DEVICE_MONITOR->callState_ = 10; 2981 ret = handler.HandleCallEnded(keyEvent); 2982 ASSERT_FALSE(ret); 2983 } 2984 2985 /** 2986 * @tc.name: KeySubscriberHandlerTest_HandleCallEnded 2987 * @tc.desc: Test HandleCallEnded 2988 * @tc.type: FUNC 2989 * @tc.require: 2990 */ 2991 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleCallEnded002, TestSize.Level1) 2992 { 2993 CALL_TEST_DEBUG; 2994 KeySubscriberHandler handler; 2995 auto keyEvent = KeyEvent::Create(); 2996 bool ret = true; 2997 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_UP); 2998 keyEvent->SetKeyCode(KeyEvent::KEYCODE_CUSTOM1); 2999 3000 DISPLAY_MONITOR->SetScreenStatus(EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_ON); 3001 DEVICE_MONITOR->callState_ = StateType::CALL_STATUS_DIALING; 3002 ret = handler.HandleCallEnded(keyEvent); 3003 ASSERT_FALSE(ret); 3004 3005 DEVICE_MONITOR->callState_ = CALL_STATUS_WAITING; 3006 ret = handler.HandleCallEnded(keyEvent); 3007 ASSERT_FALSE(ret); 3008 3009 DEVICE_MONITOR->callState_ = CALL_STATUS_DISCONNECTED; 3010 ret = handler.HandleCallEnded(keyEvent); 3011 ASSERT_FALSE(ret); 3012 3013 DEVICE_MONITOR->callState_ = CALL_STATUS_DISCONNECTING; 3014 ret = handler.HandleCallEnded(keyEvent); 3015 ASSERT_FALSE(ret); 3016 } 3017 #endif // OHOS_BUILD_ENABLE_CALL_MANAGER 3018 3019 /** 3020 * @tc.name: KeySubscriberHandlerTest_RemoveSubscriberKeyUpTimer 3021 * @tc.desc: Test RemoveSubscriberKeyUpTimer 3022 * @tc.type: FUNC 3023 * @tc.require: 3024 */ 3025 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_RemoveSubscriberKeyUpTimer001, TestSize.Level1) 3026 { 3027 CALL_TEST_DEBUG; 3028 KeySubscriberHandler handler; 3029 auto keyEvent = KeyEvent::Create(); 3030 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 3031 3032 UDSServer udsServer; 3033 auto keyOption = std::make_shared<KeyOption>(); 3034 SessionPtr sess = udsServer.GetSessionByPid(1); 3035 std::list<std::shared_ptr<OHOS::MMI::KeySubscriberHandler::Subscriber>>subscriberMap_; 3036 auto newSubscriber1 = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 3037 auto newSubscriber2 = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(2, sess, keyOption); 3038 auto newSubscriber3 = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(3, sess, keyOption); 3039 subscriberMap_.push_back(newSubscriber1); 3040 subscriberMap_.push_back(newSubscriber2); 3041 subscriberMap_.push_back(newSubscriber3); 3042 EXPECT_NO_FATAL_FAILURE(handler.RemoveSubscriberKeyUpTimer(KeyEvent::KEYCODE_POWER)); 3043 for (auto& sub : subscriberMap_) { 3044 ASSERT_EQ(sub->timerId_, -1); 3045 ASSERT_NE(sub->keyOption_->GetFinalKey(), KeyEvent::KEYCODE_POWER); 3046 } 3047 } 3048 3049 /** 3050 * @tc.name: KeySubscriberHandlerTest_IsEnableCombineKey_007 3051 * @tc.desc: Test Is Enable CombineKey 3052 * @tc.type: FUNC 3053 * @tc.require: 3054 */ 3055 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsEnableCombineKey_007, TestSize.Level1) 3056 { 3057 CALL_DEBUG_ENTER; 3058 KeySubscriberHandler handler; 3059 KeyEvent::KeyItem item; 3060 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 3061 handler.enableCombineKey_ = false; 3062 keyEvent->SetKeyCode(KeyEvent::KEYCODE_BRIGHTNESS_DOWN); 3063 item.SetKeyCode(KeyEvent::KEYCODE_A); 3064 keyEvent->AddKeyItem(item); 3065 ASSERT_TRUE(handler.IsEnableCombineKey(keyEvent)); 3066 3067 keyEvent->SetKeyCode(KeyEvent::KEYCODE_R); 3068 ASSERT_FALSE(handler.IsEnableCombineKey(keyEvent)); 3069 } 3070 3071 /** 3072 * @tc.name: KeySubscriberHandlerTest_IsEnableCombineKeyRecord_001 3073 * @tc.desc: Test is enable combine key record 3074 * @tc.type: FUNC 3075 * @tc.require: 3076 */ 3077 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsEnableCombineKeyRecord_001, TestSize.Level1) 3078 { 3079 CALL_TEST_DEBUG; 3080 KeySubscriberHandler handler; 3081 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 3082 ASSERT_NE(keyEvent, nullptr); 3083 KeyEvent::KeyItem item; 3084 item.SetKeyCode(KeyEvent::KEYCODE_CTRL_LEFT); 3085 keyEvent->AddKeyItem(item); 3086 keyEvent->SetKeyCode(KeyEvent::KEYCODE_CTRL_LEFT); 3087 ASSERT_TRUE(handler.IsEnableCombineKeyRecord(keyEvent)); 3088 3089 item.SetKeyCode(KeyEvent::KEYCODE_META_LEFT); 3090 keyEvent->AddKeyItem(item); 3091 keyEvent->SetKeyCode(KeyEvent::KEYCODE_META_LEFT); 3092 ASSERT_TRUE(handler.IsEnableCombineKeyRecord(keyEvent)); 3093 3094 item.SetKeyCode(KeyEvent::KEYCODE_DPAD_RIGHT); 3095 keyEvent->AddKeyItem(item); 3096 keyEvent->SetKeyCode(KeyEvent::KEYCODE_DPAD_RIGHT); 3097 ASSERT_TRUE(handler.IsEnableCombineKeyRecord(keyEvent)); 3098 3099 item.SetKeyCode(KeyEvent::KEYCODE_CTRL_RIGHT); 3100 keyEvent->AddKeyItem(item); 3101 keyEvent->SetKeyCode(KeyEvent::KEYCODE_CTRL_RIGHT); 3102 ASSERT_TRUE(handler.IsEnableCombineKeyRecord(keyEvent)); 3103 3104 item.SetKeyCode(KeyEvent::KEYCODE_A); 3105 keyEvent->AddKeyItem(item); 3106 keyEvent->SetKeyCode(KeyEvent::KEYCODE_A); 3107 ASSERT_TRUE(handler.IsEnableCombineKeyRecord(keyEvent)); 3108 } 3109 3110 /** 3111 * @tc.name: KeySubscriberHandlerTest_InterceptByVm_001 3112 * @tc.desc: Test InterceptByVm 3113 * @tc.type: FUNC 3114 * @tc.require: 3115 */ 3116 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_InterceptByVm_001, TestSize.Level1) 3117 { 3118 CALL_TEST_DEBUG; 3119 KeySubscriberHandler handler; 3120 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 3121 ASSERT_NE(keyEvent, nullptr); 3122 KeyEvent::KeyItem item; 3123 item.SetKeyCode(KeyEvent::KEYCODE_META_LEFT); 3124 keyEvent->AddKeyItem(item); 3125 keyEvent->SetKeyCode(KeyEvent::KEYCODE_META_LEFT); 3126 ASSERT_TRUE(handler.InterceptByVm(keyEvent)); 3127 3128 item.SetKeyCode(KeyEvent::KEYCODE_SHIFT_LEFT); 3129 keyEvent->AddKeyItem(item); 3130 keyEvent->SetKeyCode(KeyEvent::KEYCODE_SHIFT_LEFT); 3131 ASSERT_TRUE(handler.InterceptByVm(keyEvent)); 3132 3133 item.SetKeyCode(KeyEvent::KEYCODE_E); 3134 keyEvent->AddKeyItem(item); 3135 keyEvent->SetKeyCode(KeyEvent::KEYCODE_E); 3136 ASSERT_FALSE(handler.InterceptByVm(keyEvent)); 3137 } 3138 3139 /** 3140 * @tc.name: KeySubscriberHandlerTest_InterceptByVm_002 3141 * @tc.desc: Test InterceptByVm 3142 * @tc.type: FUNC 3143 * @tc.require: 3144 */ 3145 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_InterceptByVm_002, TestSize.Level1) 3146 { 3147 CALL_TEST_DEBUG; 3148 KeySubscriberHandler handler; 3149 const std::vector<int32_t> LOGO_LEFTSHIFT_E = { 3150 KeyEvent::KEYCODE_META_LEFT, KeyEvent::KEYCODE_SHIFT_LEFT, KeyEvent::KEYCODE_E}; 3151 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 3152 ASSERT_NE(keyEvent, nullptr); 3153 KeyEvent::KeyItem item; 3154 item.SetKeyCode(KeyEvent::KEYCODE_META_LEFT); 3155 keyEvent->AddKeyItem(item); 3156 keyEvent->SetKeyCode(KeyEvent::KEYCODE_META_LEFT); 3157 item.SetKeyCode(KeyEvent::KEYCODE_SHIFT_LEFT); 3158 keyEvent->AddKeyItem(item); 3159 keyEvent->SetKeyCode(KeyEvent::KEYCODE_SHIFT_LEFT); 3160 item.SetKeyCode(KeyEvent::KEYCODE_E); 3161 keyEvent->AddKeyItem(item); 3162 keyEvent->SetKeyCode(KeyEvent::KEYCODE_E); 3163 ASSERT_FALSE(handler.InterceptByVm(keyEvent)); 3164 for (auto&& keyItem : keyEvent->GetKeyItems()) { 3165 for (auto &&k : LOGO_LEFTSHIFT_E) { 3166 if (keyItem.GetKeyCode() == k) { 3167 ASSERT_FALSE(handler.InterceptByVm(keyEvent)); 3168 } 3169 } 3170 } 3171 size_t waitMatchCnt{LOGO_LEFTSHIFT_E.size()}; 3172 ASSERT_NE(waitMatchCnt, 0); 3173 ASSERT_NO_FATAL_FAILURE(handler.InterceptByVm(keyEvent)); 3174 } 3175 3176 #ifdef OHOS_BUILD_ENABLE_CALL_MANAGER 3177 /** 3178 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_011 3179 * @tc.desc: Test ring mute 3180 * @tc.type: FUNC 3181 * @tc.require: 3182 */ 3183 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_011, TestSize.Level1) 3184 { 3185 CALL_TEST_DEBUG; 3186 KeySubscriberHandler keySubscriberHandler; 3187 3188 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 3189 ASSERT_NE(keyEvent, nullptr); 3190 keyEvent->keyCode_ = KeyEvent::KEYCODE_VOLUME_UP; 3191 3192 DEVICE_MONITOR->callState_ = StateType::CALL_STATUS_INCOMING; 3193 std::shared_ptr<OHOS::Telephony::CallManagerClient> callManagerClientPtr = nullptr; 3194 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 3195 } 3196 3197 /** 3198 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_012 3199 * @tc.desc: Test ring mute 3200 * @tc.type: FUNC 3201 * @tc.require: 3202 */ 3203 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_012, TestSize.Level1) 3204 { 3205 CALL_TEST_DEBUG; 3206 KeySubscriberHandler keySubscriberHandler; 3207 3208 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 3209 ASSERT_NE(keyEvent, nullptr); 3210 keyEvent->SetKeyCode(KeyEvent::KEYCODE_VOLUME_UP); 3211 OHOS::EventFwk::Want want; 3212 want.SetParam("state", StateType::CALL_STATUS_INCOMING); 3213 OHOS::EventFwk::CommonEventData data; 3214 data.SetWant(want); 3215 int callState = 1; 3216 DEVICE_MONITOR->SetCallState(data, callState); 3217 bool result = keySubscriberHandler.HandleRingMute(keyEvent); 3218 ASSERT_FALSE(result); 3219 ASSERT_FALSE(DEVICE_MONITOR->GetHasHandleRingMute()); 3220 ASSERT_FALSE(keySubscriberHandler.needSkipPowerKeyUp_); 3221 3222 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 3223 result = keySubscriberHandler.HandleRingMute(keyEvent); 3224 ASSERT_FALSE(DEVICE_MONITOR->GetHasHandleRingMute()); 3225 } 3226 #endif // OHOS_BUILD_ENABLE_CALL_MANAGER 3227 3228 3229 /** 3230 * @tc.name: KeySubscriberHandlerTest_ProcessKeyEvent_01 3231 * @tc.desc: Test ring mute 3232 * @tc.type: FUNC 3233 * @tc.require: 3234 */ 3235 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_ProcessKeyEvent_01, TestSize.Level1) 3236 { 3237 CALL_TEST_DEBUG; 3238 KeySubscriberHandler handler; 3239 SessionPtr sess; 3240 std::shared_ptr<KeyOption> keyOption; 3241 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 3242 ASSERT_NE(keyEvent, nullptr); 3243 3244 keyEvent->SetKeyCode(KeyEvent::KEYCODE_CAMERA); 3245 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_UP); 3246 keyEvent->AddFlag(InputEvent::EVENT_FLAG_TOUCHPAD_POINTER); 3247 EXPECT_TRUE(EventLogHelper::IsBetaVersion()); 3248 EXPECT_FALSE(keyEvent->HasFlag(InputEvent::EVENT_FLAG_PRIVACY_MODE)); 3249 ASSERT_NO_FATAL_FAILURE(handler.ProcessKeyEvent(keyEvent)); 3250 } 3251 3252 /** 3253 * @tc.name: KeySubscriberHandlerTest_ProcessKeyEvent_02 3254 * @tc.desc: Test ring mute 3255 * @tc.type: FUNC 3256 * @tc.require: 3257 */ 3258 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_ProcessKeyEvent_02, TestSize.Level1) 3259 { 3260 CALL_TEST_DEBUG; 3261 KeySubscriberHandler handler; 3262 SessionPtr sess; 3263 std::shared_ptr<KeyOption> keyOption; 3264 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 3265 ASSERT_NE(keyEvent, nullptr); 3266 3267 handler.needSkipPowerKeyUp_ = true; 3268 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 3269 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_UP); 3270 std::vector<int32_t> pressedKeys; 3271 pressedKeys.push_back(KeyEvent::KEYCODE_B); 3272 pressedKeys.push_back(KeyEvent::KEYCODE_C); 3273 KeyEvent::KeyItem item; 3274 keyEvent->SetKeyCode(KeyEvent::KEYCODE_BRIGHTNESS_DOWN); 3275 item.SetKeyCode(KeyEvent::KEYCODE_A); 3276 keyEvent->AddKeyItem(item); 3277 item.SetKeyCode(KeyEvent::KEYCODE_B); 3278 keyEvent->AddKeyItem(item); 3279 keyEvent->AddPressedKeyItems(item); 3280 3281 bool result = handler.ProcessKeyEvent(keyEvent); 3282 ASSERT_FALSE(result); 3283 } 3284 3285 /** 3286 * @tc.name: KeySubscriberHandlerTest_NotifySubscriber_006 3287 * @tc.desc: Test the funcation NotifySubscriber 3288 * @tc.type: FUNC 3289 * @tc.require: 3290 */ 3291 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifySubscriber_006, TestSize.Level1) 3292 { 3293 CALL_TEST_DEBUG; 3294 KeySubscriberHandler handler; 3295 SessionPtr sess; 3296 std::shared_ptr<KeyOption> keyOption; 3297 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 3298 ASSERT_NE(keyEvent, nullptr); 3299 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 3300 KeyEvent::KeyItem item; 3301 item.SetKeyCode(KeyEvent::KEYCODE_POWER); 3302 keyEvent->AddKeyItem(item); 3303 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 3304 ASSERT_NO_FATAL_FAILURE(handler.NotifySubscriber(keyEvent, subscriber)); 3305 item.SetKeyCode(KeyEvent::KEYCODE_CAMERA); 3306 keyEvent->AddKeyItem(item); 3307 keyEvent->SetKeyCode(KeyEvent::KEYCODE_CAMERA); 3308 ASSERT_NO_FATAL_FAILURE(handler.NotifySubscriber(keyEvent, subscriber)); 3309 } 3310 3311 /** 3312 * @tc.name: KeySubscriberHandlerTest_AddTimer_002 3313 * @tc.desc: Test the funcation AddTimer 3314 * @tc.type: FUNC 3315 * @tc.require: 3316 */ 3317 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_AddTimer_002, TestSize.Level1) 3318 { 3319 CALL_TEST_DEBUG; 3320 KeySubscriberHandler handler; 3321 int32_t id = 1; 3322 SessionPtr session = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 3323 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 3324 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 3325 std::make_shared<KeySubscriberHandler::Subscriber>(id, session, keyOption); 3326 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 3327 ASSERT_NE(keyEvent, nullptr); 3328 subscriber->timerId_ = 1; 3329 bool ret = handler.AddTimer(subscriber, keyEvent); 3330 ASSERT_TRUE(ret); 3331 subscriber->keyOption_->SetFinalKeyDown(true); 3332 subscriber->keyOption_->SetFinalKeyDownDuration(0); 3333 ret = handler.AddTimer(subscriber, keyEvent); 3334 ASSERT_TRUE(ret); 3335 subscriber->keyOption_->SetFinalKeyDown(false); 3336 ret = handler.AddTimer(subscriber, keyEvent); 3337 ASSERT_TRUE(ret); 3338 } 3339 3340 /** 3341 * @tc.name: KeySubscriberHandlerTest_AddTimer_003 3342 * @tc.desc: Test the funcation AddTimer 3343 * @tc.type: FUNC 3344 * @tc.require: 3345 */ 3346 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_AddTimer_003, TestSize.Level1) 3347 { 3348 CALL_TEST_DEBUG; 3349 KeySubscriberHandler handler; 3350 int32_t id = 1; 3351 SessionPtr session = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 3352 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 3353 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 3354 std::make_shared<KeySubscriberHandler::Subscriber>(id, session, keyOption); 3355 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 3356 bool ret = handler.AddTimer(subscriber, nullptr); 3357 ASSERT_FALSE(ret); 3358 ret = handler.AddTimer(nullptr, keyEvent); 3359 ASSERT_FALSE(ret); 3360 } 3361 3362 /** 3363 * @tc.name: KeySubscriberHandlerTest_AddTimer_004 3364 * @tc.desc: Test the funcation AddTimer 3365 * @tc.type: FUNC 3366 * @tc.require: 3367 */ 3368 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_AddTimer_004, TestSize.Level1) 3369 { 3370 CALL_TEST_DEBUG; 3371 KeySubscriberHandler handler; 3372 int32_t id = 1; 3373 SessionPtr session = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 3374 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 3375 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 3376 std::make_shared<KeySubscriberHandler::Subscriber>(id, session, keyOption); 3377 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 3378 ASSERT_NE(keyEvent, nullptr); 3379 ASSERT_TRUE(handler.CloneKeyEvent(keyEvent)); 3380 auto ret = handler.AddTimer(subscriber, keyEvent); 3381 ASSERT_TRUE(ret); 3382 } 3383 3384 /** 3385 * @tc.name: KeySubscriberHandlerTest_AddTimer_005 3386 * @tc.desc: Test the funcation AddTimer 3387 * @tc.type: FUNC 3388 * @tc.require: 3389 */ 3390 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_AddTimer_005, TestSize.Level1) 3391 { 3392 CALL_TEST_DEBUG; 3393 KeySubscriberHandler handler; 3394 int32_t id = 1; 3395 SessionPtr session = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 3396 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 3397 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 3398 std::make_shared<KeySubscriberHandler::Subscriber>(id, session, keyOption); 3399 std::shared_ptr<KeyEvent> keyEvent = nullptr; 3400 subscriber->timerId_ = -1; 3401 bool ret = handler.AddTimer(subscriber, keyEvent); 3402 ASSERT_FALSE(ret); 3403 ASSERT_FALSE(handler.CloneKeyEvent(keyEvent)); 3404 } 3405 3406 /** 3407 * @tc.name: TabletSubscriberHandlerTest_SubscribeTabletProximity 3408 * @tc.desc: Test the funcation AboutSubscribeTabletProximity 3409 * @tc.type: FUNC 3410 * @tc.require: 3411 */ 3412 HWTEST_F(KeySubscriberHandlerTest, TabletSubscriberHandlerTest_SubscribeTabletProximity, TestSize.Level1) 3413 { 3414 CALL_TEST_DEBUG; 3415 auto tabletSubscriberHandler = TABLET_SCRIBER_HANDLER; 3416 SessionPtr sess; 3417 ASSERT_NO_FATAL_FAILURE(tabletSubscriberHandler->SubscribeTabletProximity(sess, 0)); 3418 ASSERT_NO_FATAL_FAILURE(tabletSubscriberHandler->SubscribeTabletProximity(sess, -1)); 3419 ASSERT_NO_FATAL_FAILURE(tabletSubscriberHandler->SubscribeTabletProximity(sess, 1)); 3420 ASSERT_NO_FATAL_FAILURE(tabletSubscriberHandler->SubscribeTabletProximity(sess, 0)); 3421 ASSERT_NO_FATAL_FAILURE(tabletSubscriberHandler->SubscribeTabletProximity(nullptr, 0)); 3422 ASSERT_NO_FATAL_FAILURE(tabletSubscriberHandler->UnsubscribetabletProximity(nullptr, 0)); 3423 ASSERT_NO_FATAL_FAILURE(tabletSubscriberHandler->UnsubscribetabletProximity(nullptr, -1)); 3424 ASSERT_NO_FATAL_FAILURE(tabletSubscriberHandler->UnsubscribetabletProximity(sess, 0)); 3425 } 3426 3427 /** 3428 * @tc.name: TabletSubscriberHandlerTest_OnSubscribeTabletProximity 3429 * @tc.desc: Test the funcation OnSubscribeTabletProximity 3430 * @tc.type: FUNC 3431 * @tc.require: 3432 */ 3433 HWTEST_F(KeySubscriberHandlerTest, TabletSubscriberHandlerTest_OnSubscribeTabletProximity, TestSize.Level1) 3434 { 3435 CALL_TEST_DEBUG; 3436 auto tabletSubscriberHandler = TABLET_SCRIBER_HANDLER; 3437 SessionPtr sess; 3438 tabletSubscriberHandler->SubscribeTabletProximity(sess, 0); 3439 auto pointerEvent = std::make_shared<PointerEvent>(0); 3440 ASSERT_NO_FATAL_FAILURE(tabletSubscriberHandler->OnSubscribeTabletProximity(pointerEvent)); 3441 auto pointerEvent2 = std::make_shared<PointerEvent>(PointerEvent::POINTER_ACTION_PROXIMITY_OUT); 3442 ASSERT_NO_FATAL_FAILURE(tabletSubscriberHandler->OnSubscribeTabletProximity(pointerEvent2)); 3443 auto pointerEvent3 = std::make_shared<PointerEvent>(PointerEvent::POINTER_ACTION_PROXIMITY_IN); 3444 ASSERT_NO_FATAL_FAILURE(tabletSubscriberHandler->OnSubscribeTabletProximity(pointerEvent3)); 3445 } 3446 3447 /** 3448 * @tc.name: TabletSubscriberHandlerTest_OnSessionDelete 3449 * @tc.desc: Test the funcation OnSessionDelete 3450 * @tc.type: FUNC 3451 * @tc.require: 3452 */ 3453 HWTEST_F(KeySubscriberHandlerTest, TabletSubscriberHandlerTest_OnSessionDelete, TestSize.Level1) 3454 { 3455 CALL_TEST_DEBUG; 3456 auto tabletSubscriberHandler = TABLET_SCRIBER_HANDLER; 3457 SessionPtr sess; 3458 SessionPtr sess2; 3459 tabletSubscriberHandler->SubscribeTabletProximity(sess, 0); 3460 tabletSubscriberHandler->SubscribeTabletProximity(sess2, 0); 3461 ASSERT_NO_FATAL_FAILURE(tabletSubscriberHandler->OnSessionDelete(sess)); 3462 ASSERT_NO_FATAL_FAILURE(tabletSubscriberHandler->OnSessionDelete(sess)); 3463 } 3464 } // namespace MMI 3465 } // namespace OHOS 3466