1 /* 2 * Copyright (c) 2024 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include <fstream> 17 #include <list> 18 19 #include <gtest/gtest.h> 20 21 #include "key_option.h" 22 #include "key_subscriber_handler.h" 23 #include "key_shortcut_manager.h" 24 #include "call_manager_client.h" 25 #include "common_event_data.h" 26 #include "common_event_manager.h" 27 #include "common_event_support.h" 28 #include "device_event_monitor.h" 29 #include "display_event_monitor.h" 30 #include "input_event_handler.h" 31 #include "key_event.h" 32 #include "mmi_log.h" 33 #include "nap_process.h" 34 #include "switch_subscriber_handler.h" 35 #include "uds_server.h" 36 #include "want.h" 37 #include "event_log_helper.h" 38 39 #undef MMI_LOG_TAG 40 #define MMI_LOG_TAG "KeyCommandHandlerTest" 41 42 namespace OHOS { 43 namespace MMI { 44 namespace { 45 using namespace testing::ext; 46 const std::string PROGRAM_NAME = "uds_session_test"; 47 constexpr int32_t MODULE_TYPE = 1; 48 constexpr int32_t UDS_FD = 1; 49 constexpr int32_t UDS_UID = 100; 50 constexpr int32_t UDS_PID = 100; 51 constexpr int32_t REMOVE_OBSERVER { -2 }; 52 constexpr int32_t UNOBSERVED { -1 }; 53 constexpr int32_t ACTIVE_EVENT { 2 }; 54 } // namespace 55 56 class KeySubscriberHandlerTest : public testing::Test { 57 public: SetUpTestCase(void)58 static void SetUpTestCase(void) {} TearDownTestCase(void)59 static void TearDownTestCase(void) {} 60 }; 61 62 /** 63 * @tc.name: KeySubscriberHandlerTest_HandleKeyEvent_001 64 * @tc.desc: Test HandleKeyEvent 65 * @tc.type: FUNC 66 * @tc.require: 67 */ 68 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleKeyEvent_001, TestSize.Level1) 69 { 70 CALL_DEBUG_ENTER; 71 KeySubscriberHandler handler; 72 KeyEvent::KeyItem item; 73 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 74 ASSERT_NE(keyEvent, nullptr); 75 handler.enableCombineKey_ = false; 76 keyEvent->SetKeyCode(KeyEvent::KEYCODE_BRIGHTNESS_DOWN); 77 item.SetKeyCode(KeyEvent::KEYCODE_A); 78 keyEvent->AddKeyItem(item); 79 item.SetKeyCode(KeyEvent::KEYCODE_B); 80 keyEvent->AddKeyItem(item); 81 EXPECT_FALSE(handler.OnSubscribeKeyEvent(keyEvent)); 82 ASSERT_NO_FATAL_FAILURE(handler.HandleKeyEvent(keyEvent)); 83 84 handler.enableCombineKey_ = true; 85 handler.hasEventExecuting_ = true; 86 handler.keyEvent_ = KeyEvent::Create(); 87 ASSERT_NE(handler.keyEvent_, nullptr); 88 handler.keyEvent_->SetKeyCode(KeyEvent::KEYCODE_BRIGHTNESS_DOWN); 89 handler.keyEvent_->SetKeyAction(KeyEvent::KEY_ACTION_UP); 90 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_UP); 91 item.SetKeyCode(KeyEvent::KEYCODE_A); 92 handler.keyEvent_->AddKeyItem(item); 93 item.SetKeyCode(KeyEvent::KEYCODE_B); 94 handler.keyEvent_->AddKeyItem(item); 95 EXPECT_TRUE(handler.OnSubscribeKeyEvent(keyEvent)); 96 EXPECT_FALSE(EventLogHelper::IsBetaVersion()); 97 EXPECT_FALSE(keyEvent->HasFlag(InputEvent::EVENT_FLAG_PRIVACY_MODE)); 98 ASSERT_NO_FATAL_FAILURE(handler.HandleKeyEvent(keyEvent)); 99 } 100 101 /** 102 * @tc.name: KeySubscriberHandlerTest_DumpSubscriber_001 103 * @tc.desc: Test DumpSubscriber 104 * @tc.type: FUNC 105 * @tc.require: 106 */ 107 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_DumpSubscriber_001, TestSize.Level1) 108 { 109 CALL_TEST_DEBUG; 110 KeySubscriberHandler handler; 111 int32_t fd = 1; 112 SessionPtr sess; 113 auto keyOption = std::make_shared<KeyOption>(); 114 keyOption->preKeys_.insert(10); 115 keyOption->preKeys_.insert(20); 116 keyOption->preKeys_.insert(30); 117 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 118 ASSERT_NO_FATAL_FAILURE(handler.DumpSubscriber(fd, subscriber)); 119 } 120 121 /** 122 * @tc.name: InputWindowsManagerTest_UnsubscribeKeyEvent_001 123 * @tc.desc: Test UnsubscribeKeyEvent 124 * @tc.type: FUNC 125 * @tc.require: 126 */ 127 HWTEST_F(KeySubscriberHandlerTest, InputWindowsManagerTest_UnsubscribeKeyEvent_001, TestSize.Level1) 128 { 129 CALL_TEST_DEBUG; 130 KeySubscriberHandler keySubscriberHandler; 131 auto keyEvent = KeyEvent::Create(); 132 ASSERT_NE(keyEvent, nullptr); 133 keySubscriberHandler.HandleKeyEvent(keyEvent); 134 auto pointerEvent = PointerEvent::Create(); 135 keySubscriberHandler.HandlePointerEvent(pointerEvent); 136 keySubscriberHandler.HandleTouchEvent(pointerEvent); 137 keySubscriberHandler.RemoveSubscriberKeyUpTimer(1); 138 std::vector<std::string> args = {}; 139 keySubscriberHandler.Dump(1, args); 140 UDSServer udsServer; 141 SessionPtr sess = udsServer.GetSessionByPid(1); 142 std::shared_ptr<KeyOption> keyOption = nullptr; 143 ASSERT_EQ(keySubscriberHandler.SubscribeKeyEvent(sess, -1, keyOption), -1); 144 SessionPtr sessPtr = nullptr; 145 ASSERT_NE(keySubscriberHandler.UnsubscribeKeyEvent(sessPtr, -1), 0); 146 ASSERT_NE(keySubscriberHandler.UnsubscribeKeyEvent(sess, 1), 0); 147 } 148 149 /** 150 * @tc.name: KeySubscriberHandlerTest_IsEnableCombineKey_001 151 * @tc.desc: Test IsEnableCombineKey 152 * @tc.type: FUNC 153 * @tc.require: 154 */ 155 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsEnableCombineKey_001, TestSize.Level1) 156 { 157 CALL_TEST_DEBUG; 158 KeySubscriberHandler keySubscriberHandler; 159 keySubscriberHandler.EnableCombineKey(false); 160 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 161 CHKPV(keyEvent); 162 KeyEvent::KeyItem item; 163 item.SetKeyCode(KeyEvent::KEYCODE_POWER); 164 keyEvent->AddKeyItem(item); 165 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 166 keySubscriberHandler.HandleKeyEvent(keyEvent); 167 ASSERT_EQ(keySubscriberHandler.EnableCombineKey(true), RET_OK); 168 } 169 170 /** 171 * @tc.name: KeySubscriberHandlerTest_IsEnableCombineKey_002 172 * @tc.desc: Test IsEnableCombineKey 173 * @tc.type: FUNC 174 * @tc.require: 175 */ 176 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsEnableCombineKey_002, TestSize.Level1) 177 { 178 CALL_TEST_DEBUG; 179 KeySubscriberHandler keySubscriberHandler; 180 keySubscriberHandler.EnableCombineKey(false); 181 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 182 CHKPV(keyEvent); 183 KeyEvent::KeyItem item1; 184 item1.SetKeyCode(KeyEvent::KEYCODE_META_LEFT); 185 keyEvent->AddKeyItem(item1); 186 KeyEvent::KeyItem item2; 187 item2.SetKeyCode(KeyEvent::KEYCODE_L); 188 keyEvent->AddKeyItem(item2); 189 keyEvent->SetKeyCode(KeyEvent::KEYCODE_L); 190 ASSERT_EQ(keySubscriberHandler.EnableCombineKey(true), RET_OK); 191 } 192 193 /** 194 * @tc.name: KeySubscriberHandlerTest_EnableCombineKey_001 195 * @tc.desc: Test enable combineKey 196 * @tc.type: FUNC 197 * @tc.require: 198 */ 199 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_EnableCombineKey_001, TestSize.Level1) 200 { 201 CALL_TEST_DEBUG; 202 KeySubscriberHandler keySubscriberHandler; 203 ASSERT_EQ(keySubscriberHandler.EnableCombineKey(true), RET_OK); 204 } 205 206 /** 207 * @tc.name: KeySubscriberHandlerTest_SubscribeKeyEvent_001 208 * @tc.desc: Test subscribe keyEvent 209 * @tc.type: FUNC 210 * @tc.require: 211 */ 212 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_SubscribeKeyEvent_001, TestSize.Level1) 213 { 214 CALL_DEBUG_ENTER; 215 KeySubscriberHandler handler; 216 SessionPtr sess; 217 auto keyOption = std::make_shared<KeyOption>(); 218 int32_t ret = handler.SubscribeKeyEvent(sess, -1, keyOption); 219 ASSERT_EQ(ret, RET_ERR); 220 ret = handler.SubscribeKeyEvent(nullptr, 1, keyOption); 221 ASSERT_NE(ret, RET_OK); 222 ret = handler.SubscribeKeyEvent(sess, 1, keyOption); 223 ASSERT_NE(ret, RET_OK); 224 } 225 226 /** 227 * @tc.name: KeySubscriberHandlerTest_RemoveSubscriber_001 228 * @tc.desc: Test remove subscriber 229 * @tc.type: FUNC 230 * @tc.require: 231 */ 232 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_RemoveSubscriber_001, TestSize.Level1) 233 { 234 CALL_DEBUG_ENTER; 235 KeySubscriberHandler handler; 236 SessionPtr sess; 237 int32_t ret = handler.RemoveSubscriber(sess, 1, true); 238 ASSERT_EQ(ret, RET_ERR); 239 ret = handler.RemoveSubscriber(nullptr, 1, true); 240 ASSERT_EQ(ret, RET_ERR); 241 } 242 243 /** 244 * @tc.name: KeySubscriberHandlerTest_IsEqualKeyOption_001 245 * @tc.desc: Test is equal keyOption 246 * @tc.type: FUNC 247 * @tc.require: 248 */ 249 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsEqualKeyOption_001, TestSize.Level1) 250 { 251 CALL_DEBUG_ENTER; 252 KeySubscriberHandler handler; 253 auto newOption = std::make_shared<KeyOption>(); 254 auto oldOption = std::make_shared<KeyOption>(); 255 newOption->SetPreKeys({1, 2, 3}); 256 oldOption->SetPreKeys({4, 5, 6}); 257 ASSERT_FALSE(handler.IsEqualKeyOption(newOption, oldOption)); 258 newOption->SetFinalKey(1); 259 oldOption->SetFinalKey(2); 260 ASSERT_FALSE(handler.IsEqualKeyOption(newOption, oldOption)); 261 newOption->SetFinalKeyDown(true); 262 oldOption->SetFinalKeyDown(false); 263 ASSERT_FALSE(handler.IsEqualKeyOption(newOption, oldOption)); 264 newOption->SetFinalKeyDownDuration(100); 265 oldOption->SetFinalKeyDownDuration(200); 266 ASSERT_FALSE(handler.IsEqualKeyOption(newOption, oldOption)); 267 newOption->SetFinalKeyUpDelay(100); 268 oldOption->SetFinalKeyUpDelay(200); 269 ASSERT_FALSE(handler.IsEqualKeyOption(newOption, oldOption)); 270 newOption->SetPreKeys({1, 2, 3}); 271 oldOption->SetPreKeys({1, 2, 3}); 272 newOption->SetFinalKey(1); 273 oldOption->SetFinalKey(1); 274 newOption->SetFinalKeyDown(true); 275 oldOption->SetFinalKeyDown(true); 276 newOption->SetFinalKeyDownDuration(100); 277 oldOption->SetFinalKeyDownDuration(100); 278 newOption->SetFinalKeyUpDelay(100); 279 oldOption->SetFinalKeyUpDelay(100); 280 ASSERT_TRUE(handler.IsEqualKeyOption(newOption, oldOption)); 281 } 282 283 /** 284 * @tc.name: KeySubscriberHandlerTest_IsPreKeysMatch_001 285 * @tc.desc: Test is preKeys match 286 * @tc.type: FUNC 287 * @tc.require: 288 */ 289 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsPreKeysMatch_001, TestSize.Level1) 290 { 291 CALL_DEBUG_ENTER; 292 KeySubscriberHandler handler; 293 std::set<int32_t> preKeys; 294 std::vector<int32_t> pressedKeys = {1, 2, 3}; 295 ASSERT_TRUE(handler.IsPreKeysMatch(preKeys, pressedKeys)); 296 preKeys = {1, 2, 3}; 297 ASSERT_TRUE(handler.IsPreKeysMatch(preKeys, pressedKeys)); 298 pressedKeys = {1, 2, 3, 4}; 299 ASSERT_FALSE(handler.IsPreKeysMatch(preKeys, pressedKeys)); 300 pressedKeys = {1, 2, 3}; 301 preKeys = {1, 2, 3, 4}; 302 ASSERT_FALSE(handler.IsPreKeysMatch(preKeys, pressedKeys)); 303 } 304 305 /** 306 * @tc.name: KeySubscriberHandlerTest_IsEqualPreKeys_001 307 * @tc.desc: Test is equal preKeys 308 * @tc.type: FUNC 309 * @tc.require: 310 */ 311 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsEqualPreKeys_001, TestSize.Level1) 312 { 313 CALL_TEST_DEBUG; 314 KeySubscriberHandler handler; 315 std::set<int32_t> preKeys = {1, 2, 3}; 316 std::set<int32_t> pressedKeys = {4, 5, 6}; 317 ASSERT_FALSE(handler.IsEqualPreKeys(preKeys, pressedKeys)); 318 pressedKeys = {1, 2, 3}; 319 ASSERT_TRUE(handler.IsEqualPreKeys(preKeys, pressedKeys)); 320 pressedKeys = {1, 2}; 321 ASSERT_FALSE(handler.IsEqualPreKeys(preKeys, pressedKeys)); 322 } 323 324 /** 325 * @tc.name: KeySubscriberHandlerTest_IsMatchForegroundPid_001 326 * @tc.desc: Test is match foreground pid 327 * @tc.type: FUNC 328 * @tc.require: 329 */ 330 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsMatchForegroundPid_001, TestSize.Level1) 331 { 332 CALL_TEST_DEBUG; 333 KeySubscriberHandler handler; 334 std::list<std::shared_ptr<OHOS::MMI::KeySubscriberHandler::Subscriber>> subs; 335 std::set<int32_t> foregroundPids = {1, 2, 3}; 336 ASSERT_FALSE(handler.IsMatchForegroundPid(subs, foregroundPids)); 337 } 338 339 /** 340 * @tc.name: KeySubscriberHandlerTest_NotifyKeyDownSubscriber_001 341 * @tc.desc: Test notify key down subscriber 342 * @tc.type: FUNC 343 * @tc.require: 344 */ 345 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifyKeyDownSubscriber_001, TestSize.Level1) 346 { 347 CALL_TEST_DEBUG; 348 KeySubscriberHandler handler; 349 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 350 auto keyOption = std::make_shared<KeyOption>(); 351 std::list<std::shared_ptr<OHOS::MMI::KeySubscriberHandler::Subscriber>> subscribers; 352 bool handled = false; 353 ASSERT_NO_FATAL_FAILURE(handler.NotifyKeyDownSubscriber(keyEvent, keyOption, subscribers, handled)); 354 keyEvent = nullptr; 355 ASSERT_NO_FATAL_FAILURE(handler.NotifyKeyDownSubscriber(keyEvent, keyOption, subscribers, handled)); 356 } 357 358 /** 359 * @tc.name: KeySubscriberHandlerTest_NotifyKeyDownRightNow_001 360 * @tc.desc: Test notify key down right now 361 * @tc.type: FUNC 362 * @tc.require: 363 */ 364 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifyKeyDownRightNow_001, TestSize.Level1) 365 { 366 CALL_TEST_DEBUG; 367 KeySubscriberHandler handler; 368 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 369 std::list<std::shared_ptr<OHOS::MMI::KeySubscriberHandler::Subscriber>> subscribers; 370 bool handled = false; 371 handler.NotifyKeyDownRightNow(keyEvent, subscribers, true, handled); 372 ASSERT_FALSE(handled); 373 } 374 375 /** 376 * @tc.name: KeySubscriberHandlerTest_NotifyKeyDownDelay_001 377 * @tc.desc: Test notify key down delay 378 * @tc.type: FUNC 379 * @tc.require: 380 */ 381 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifyKeyDownDelay_001, TestSize.Level1) 382 { 383 CALL_DEBUG_ENTER; 384 KeySubscriberHandler handler; 385 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 386 CHKPV(keyEvent); 387 KeyEvent::KeyItem item; 388 item.SetKeyCode(KeyEvent::KEYCODE_POWER); 389 keyEvent->AddKeyItem(item); 390 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 391 std::list<std::shared_ptr<OHOS::MMI::KeySubscriberHandler::Subscriber>> subscribers; 392 bool handled = false; 393 handler.NotifyKeyDownDelay(keyEvent, subscribers, handled); 394 ASSERT_FALSE(handled); 395 } 396 397 /** 398 * @tc.name: KeySubscriberHandlerTest_InitSessionDeleteCallback_001 399 * @tc.desc: Test init session delete callback 400 * @tc.type: FUNC 401 * @tc.require: 402 */ 403 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_InitSessionDeleteCallback_001, TestSize.Level1) 404 { 405 CALL_DEBUG_ENTER; 406 KeySubscriberHandler handler; 407 handler.callbackInitialized_ = true; 408 ASSERT_TRUE(handler.InitSessionDeleteCallback()); 409 handler.callbackInitialized_ = false; 410 ASSERT_FALSE(handler.InitSessionDeleteCallback()); 411 } 412 413 /** 414 * @tc.name: KeySubscriberHandlerTest_HandleKeyDown_001 415 * @tc.desc: Test handle key down 416 * @tc.type: FUNC 417 * @tc.require: 418 */ 419 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleKeyDown_001, TestSize.Level1) 420 { 421 CALL_DEBUG_ENTER; 422 KeySubscriberHandler handler; 423 auto result = handler.HandleKeyDown(nullptr); 424 ASSERT_FALSE(result); 425 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 426 CHKPV(keyEvent); 427 result = handler.HandleKeyDown(keyEvent); 428 ASSERT_FALSE(result); 429 } 430 431 /** 432 * @tc.name: KeySubscriberHandlerTest_RemoveKeyCode_001 433 * @tc.desc: Test remove key code 434 * @tc.type: FUNC 435 * @tc.require: 436 */ 437 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_RemoveKeyCode_001, TestSize.Level1) 438 { 439 CALL_TEST_DEBUG; 440 KeySubscriberHandler handler; 441 std::vector<int32_t> keyCodes; 442 handler.RemoveKeyCode(1, keyCodes); 443 ASSERT_TRUE(keyCodes.empty()); 444 keyCodes = {2, 3, 4}; 445 handler.RemoveKeyCode(1, keyCodes); 446 ASSERT_EQ(keyCodes, (std::vector<int32_t>{2, 3, 4})); 447 keyCodes = {1, 2, 3}; 448 ASSERT_EQ(keyCodes, (std::vector<int32_t>{1, 2, 3})); 449 } 450 451 /** 452 * @tc.name: KeySubscriberHandlerTest_IsFunctionKey_001 453 * @tc.desc: Test is function key 454 * @tc.type: FUNC 455 * @tc.require: 456 */ 457 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsFunctionKey_001, TestSize.Level1) 458 { 459 CALL_TEST_DEBUG; 460 KeySubscriberHandler handler; 461 auto keyEvent = std::make_shared<KeyEvent>(KeyEvent::KEYCODE_BRIGHTNESS_DOWN); 462 ASSERT_FALSE(handler.IsFunctionKey(keyEvent)); 463 keyEvent = std::make_shared<KeyEvent>(KeyEvent::KEYCODE_BRIGHTNESS_UP); 464 ASSERT_FALSE(handler.IsFunctionKey(keyEvent)); 465 keyEvent = std::make_shared<KeyEvent>(KeyEvent::KEYCODE_MUTE); 466 ASSERT_FALSE(handler.IsFunctionKey(keyEvent)); 467 keyEvent = std::make_shared<KeyEvent>(KeyEvent::KEYCODE_SWITCHVIDEOMODE); 468 ASSERT_FALSE(handler.IsFunctionKey(keyEvent)); 469 keyEvent = std::make_shared<KeyEvent>(KeyEvent::KEYCODE_WLAN); 470 ASSERT_FALSE(handler.IsFunctionKey(keyEvent)); 471 keyEvent = std::make_shared<KeyEvent>(KeyEvent::KEYCODE_CONFIG); 472 ASSERT_FALSE(handler.IsFunctionKey(keyEvent)); 473 keyEvent = std::make_shared<KeyEvent>(KeyEvent::KEYCODE_A); 474 ASSERT_FALSE(handler.IsFunctionKey(keyEvent)); 475 } 476 477 /** 478 * @tc.name: KeySubscriberHandlerTest_CloneKeyEvent_001 479 * @tc.desc: Test clone key event 480 * @tc.type: FUNC 481 * @tc.require: 482 */ 483 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_CloneKeyEvent_001, TestSize.Level1) 484 { 485 CALL_TEST_DEBUG; 486 KeySubscriberHandler handler; 487 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 488 ASSERT_NE(keyEvent, nullptr); 489 ASSERT_TRUE(handler.CloneKeyEvent(keyEvent)); 490 handler.keyEvent_ = nullptr; 491 ASSERT_TRUE(handler.CloneKeyEvent(keyEvent)); 492 } 493 494 /** 495 * @tc.name: KeySubscriberHandlerTest_NotifyKeyUpSubscriber_001 496 * @tc.desc: Test notify key up subscriber 497 * @tc.type: FUNC 498 * @tc.require: 499 */ 500 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifyKeyUpSubscriber_001, TestSize.Level1) 501 { 502 CALL_TEST_DEBUG; 503 KeySubscriberHandler handler; 504 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 505 ASSERT_NE(keyEvent, nullptr); 506 std::list<std::shared_ptr<OHOS::MMI::KeySubscriberHandler::Subscriber>> subscribers; 507 bool handled = false; 508 handler.NotifyKeyUpSubscriber(keyEvent, subscribers, handled); 509 ASSERT_FALSE(handled); 510 handler.isForegroundExits_ = false; 511 handler.NotifyKeyUpSubscriber(keyEvent, subscribers, handled); 512 ASSERT_FALSE(handled); 513 handler.isForegroundExits_ = true; 514 handler.foregroundPids_.clear(); 515 handler.NotifyKeyUpSubscriber(keyEvent, subscribers, handled); 516 ASSERT_FALSE(handled); 517 } 518 519 /** 520 * @tc.name: KeySubscriberHandlerTest_IsEnableCombineKeySwipe_001 521 * @tc.desc: Test is enable combine key swipe 522 * @tc.type: FUNC 523 * @tc.require: 524 */ 525 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsEnableCombineKeySwipe_001, TestSize.Level1) 526 { 527 CALL_TEST_DEBUG; 528 KeySubscriberHandler handler; 529 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 530 ASSERT_NE(keyEvent, nullptr); 531 KeyEvent::KeyItem item; 532 item.SetKeyCode(KeyEvent::KEYCODE_CTRL_LEFT); 533 keyEvent->AddKeyItem(item); 534 keyEvent->SetKeyCode(KeyEvent::KEYCODE_CTRL_LEFT); 535 ASSERT_TRUE(handler.IsEnableCombineKeySwipe(keyEvent)); 536 item.SetKeyCode(KeyEvent::KEYCODE_META_LEFT); 537 keyEvent->AddKeyItem(item); 538 keyEvent->SetKeyCode(KeyEvent::KEYCODE_META_LEFT); 539 ASSERT_TRUE(handler.IsEnableCombineKeySwipe(keyEvent)); 540 item.SetKeyCode(KeyEvent::KEYCODE_DPAD_RIGHT); 541 keyEvent->AddKeyItem(item); 542 keyEvent->SetKeyCode(KeyEvent::KEYCODE_DPAD_RIGHT); 543 ASSERT_TRUE(handler.IsEnableCombineKeySwipe(keyEvent)); 544 item.SetKeyCode(KeyEvent::KEYCODE_CTRL_RIGHT); 545 keyEvent->AddKeyItem(item); 546 keyEvent->SetKeyCode(KeyEvent::KEYCODE_CTRL_RIGHT); 547 ASSERT_TRUE(handler.IsEnableCombineKeySwipe(keyEvent)); 548 item.SetKeyCode(KeyEvent::KEYCODE_A); 549 keyEvent->AddKeyItem(item); 550 keyEvent->SetKeyCode(KeyEvent::KEYCODE_A); 551 ASSERT_TRUE(handler.IsEnableCombineKeySwipe(keyEvent)); 552 } 553 554 /** 555 * @tc.name: KeySubscriberHandlerTest_OnSubscribeKeyEvent_001 556 * @tc.desc: Test on subscribe key event 557 * @tc.type: FUNC 558 * @tc.require: 559 */ 560 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_OnSubscribeKeyEvent_001, TestSize.Level1) 561 { 562 CALL_TEST_DEBUG; 563 KeySubscriberHandler handler; 564 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 565 ASSERT_NE(keyEvent, nullptr); 566 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 567 ASSERT_FALSE(handler.OnSubscribeKeyEvent(keyEvent)); 568 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_UP); 569 ASSERT_FALSE(handler.OnSubscribeKeyEvent(keyEvent)); 570 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_CANCEL); 571 ASSERT_FALSE(handler.OnSubscribeKeyEvent(keyEvent)); 572 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_CANCEL); 573 ASSERT_FALSE(handler.OnSubscribeKeyEvent(keyEvent)); 574 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 575 handler.OnSubscribeKeyEvent(keyEvent); 576 ASSERT_FALSE(handler.OnSubscribeKeyEvent(keyEvent)); 577 } 578 579 /** 580 * @tc.name: KeySubscriberHandlerTest_OnSessionDelete_001 581 * @tc.desc: Test onSession delete 582 * @tc.type: FUNC 583 * @tc.require: 584 */ 585 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_OnSessionDelete_001, TestSize.Level1) 586 { 587 CALL_TEST_DEBUG; 588 KeySubscriberHandler handler; 589 UDSServer udsServer; 590 auto keyOption = std::make_shared<KeyOption>(); 591 SessionPtr sess = udsServer.GetSessionByPid(1); 592 std::list<std::shared_ptr<OHOS::MMI::KeySubscriberHandler::Subscriber>>subscriberMap_; 593 auto newSubscriber1 = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 594 auto newSubscriber2 = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(2, sess, keyOption); 595 auto newSubscriber3 = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(3, sess, keyOption); 596 subscriberMap_.push_back(newSubscriber1); 597 subscriberMap_.push_back(newSubscriber2); 598 subscriberMap_.push_back(newSubscriber3); 599 handler.OnSessionDelete(sess); 600 for (auto& sub : subscriberMap_) { 601 ASSERT_EQ(sub->sess_, nullptr); 602 } 603 } 604 605 /** 606 * @tc.name: KeySubscriberHandlerTest_ClearSubscriberTimer_001 607 * @tc.desc: Test clear subscriber timer 608 * @tc.type: FUNC 609 * @tc.require: 610 */ 611 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_ClearSubscriberTimer_001, TestSize.Level1) 612 { 613 CALL_TEST_DEBUG; 614 KeySubscriberHandler handler; 615 SessionPtr sess; 616 std::shared_ptr<KeyOption> keyOption; 617 std::list<std::shared_ptr<OHOS::MMI::KeySubscriberHandler::Subscriber>> subscribers; 618 auto subscriber1 = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 619 auto subscriber2 = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(2, sess, keyOption); 620 subscribers.push_back(subscriber1); 621 subscribers.push_back(subscriber2); 622 ASSERT_NO_FATAL_FAILURE(handler.ClearSubscriberTimer(subscribers)); 623 } 624 625 /** 626 * @tc.name: KeySubscriberHandlerTest_SubscriberNotifyNap_001 627 * @tc.desc: Test SubscriberNotifyNap 628 * @tc.type: FUNC 629 * @tc.require: 630 */ 631 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_SubscriberNotifyNap_001, TestSize.Level1) 632 { 633 CALL_TEST_DEBUG; 634 KeySubscriberHandler handler; 635 SessionPtr sess; 636 std::shared_ptr<KeyOption> keyOption; 637 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 638 ASSERT_NO_FATAL_FAILURE(handler.SubscriberNotifyNap(subscriber)); 639 } 640 641 /** 642 * @tc.name: KeySubscriberHandlerTest_HandleKeyUp_001 643 * @tc.desc: Test HandleKeyUp 644 * @tc.type: FUNC 645 * @tc.require: 646 */ 647 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleKeyUp_001, TestSize.Level1) 648 { 649 CALL_TEST_DEBUG; 650 KeySubscriberHandler handler; 651 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 652 ASSERT_NE(keyEvent, nullptr); 653 KeyEvent::KeyItem item; 654 item.SetKeyCode(KeyEvent::KEYCODE_POWER); 655 keyEvent->AddKeyItem(item); 656 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 657 bool handled = handler.HandleKeyUp(keyEvent); 658 EXPECT_FALSE(handled); 659 } 660 661 /** 662 * @tc.name: KeySubscriberHandlerTest_NotifySubscriber_001 663 * @tc.desc: Test NotifySubscriber 664 * @tc.type: FUNC 665 * @tc.require: 666 */ 667 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifySubscriber_001, TestSize.Level1) 668 { 669 CALL_TEST_DEBUG; 670 KeySubscriberHandler handler; 671 SessionPtr sess; 672 std::shared_ptr<KeyOption> keyOption; 673 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 674 ASSERT_NE(keyEvent, nullptr); 675 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 676 KeyEvent::KeyItem item; 677 item.SetKeyCode(KeyEvent::KEYCODE_POWER); 678 keyEvent->AddKeyItem(item); 679 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 680 ASSERT_NO_FATAL_FAILURE(handler.NotifySubscriber(keyEvent, subscriber)); 681 } 682 683 /** 684 * @tc.name: KeySubscriberHandlerTest_HandleKeyCancel_001 685 * @tc.desc: Test HandleKeyCancel 686 * @tc.type: FUNC 687 * @tc.require: 688 */ 689 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleKeyCancel_001, TestSize.Level1) 690 { 691 CALL_TEST_DEBUG; 692 KeySubscriberHandler handler; 693 UDSServer udsServer; 694 SessionPtr sess = udsServer.GetSessionByPid(1); 695 auto keyOption = std::make_shared<KeyOption>(); 696 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 697 ASSERT_NE(keyEvent, nullptr); 698 std::list<std::shared_ptr<OHOS::MMI::KeySubscriberHandler::Subscriber>>subscriberMap_; 699 auto newSubscriber1 = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 700 auto newSubscriber2 = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(2, sess, keyOption); 701 subscriberMap_.push_back(newSubscriber1); 702 subscriberMap_.push_back(newSubscriber2); 703 EXPECT_FALSE(handler.HandleKeyCancel(keyEvent)); 704 } 705 706 /** 707 * @tc.name: KeySubscriberHandlerTest_PrintKeyOption_001 708 * @tc.desc: Test PrintKeyOption 709 * @tc.type: FUNC 710 * @tc.require: 711 */ 712 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_PrintKeyOption_001, TestSize.Level1) 713 { 714 CALL_TEST_DEBUG; 715 KeySubscriberHandler handler; 716 auto keyOption = std::make_shared<KeyOption>(); 717 keyOption->SetFinalKey(1); 718 keyOption->SetFinalKeyDown(true); 719 keyOption->SetFinalKeyDownDuration(1000); 720 keyOption->SetPreKeys({1, 2, 3}); 721 ASSERT_NO_FATAL_FAILURE(handler.PrintKeyOption(keyOption)); 722 } 723 724 /** 725 * @tc.name: KeySubscriberHandlerTest_HandleKeyUpWithDelay_002 726 * @tc.desc: Test HandleKeyUpWithDelay 727 * @tc.type: FUNC 728 * @tc.require: 729 */ 730 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleKeyUpWithDelay_002, TestSize.Level1) 731 { 732 CALL_TEST_DEBUG; 733 KeySubscriberHandler handler; 734 SessionPtr sess; 735 auto keyOption = std::make_shared<KeyOption>(); 736 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 737 ASSERT_NE(keyEvent, nullptr); 738 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 739 740 subscriber->keyOption_->finalKeyUpDelay_ = -2; 741 ASSERT_NO_FATAL_FAILURE(handler.HandleKeyUpWithDelay(keyEvent, subscriber)); 742 } 743 744 /** 745 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_001 746 * @tc.desc: Test ring mute 747 * @tc.type: FUNC 748 * @tc.require: 749 */ 750 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_001, TestSize.Level1) 751 { 752 CALL_TEST_DEBUG; 753 KeySubscriberHandler keySubscriberHandler; 754 OHOS::EventFwk::Want want; 755 want.SetParam("state", StateType::CALL_STATUS_INCOMING); 756 OHOS::EventFwk::CommonEventData data; 757 data.SetWant(want); 758 int callState = 0; 759 DEVICE_MONITOR->SetCallState(data, callState); 760 761 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 762 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 763 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 764 } 765 766 /** 767 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_002 768 * @tc.desc: Test ring mute 769 * @tc.type: FUNC 770 * @tc.require: 771 */ 772 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_002, TestSize.Level1) 773 { 774 CALL_TEST_DEBUG; 775 KeySubscriberHandler keySubscriberHandler; 776 OHOS::EventFwk::Want want; 777 want.SetParam("state", StateType::CALL_STATUS_DISCONNECTED); 778 OHOS::EventFwk::CommonEventData data; 779 data.SetWant(want); 780 int callState = 0; 781 DEVICE_MONITOR->SetCallState(data, callState); 782 want.SetParam("state", StateType::CALL_STATUS_INCOMING); 783 data.SetWant(want); 784 callState = 0; 785 DEVICE_MONITOR->SetCallState(data, callState); 786 787 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 788 keyEvent->SetKeyCode(KeyEvent::KEYCODE_VOLUME_DOWN); 789 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 790 } 791 792 /** 793 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_003 794 * @tc.desc: Test ring mute 795 * @tc.type: FUNC 796 * @tc.require: 797 */ 798 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_003, TestSize.Level1) 799 { 800 CALL_TEST_DEBUG; 801 KeySubscriberHandler keySubscriberHandler; 802 OHOS::EventFwk::Want want; 803 want.SetParam("state", StateType::CALL_STATUS_DISCONNECTED); 804 OHOS::EventFwk::CommonEventData data; 805 data.SetWant(want); 806 int callState = 0; 807 DEVICE_MONITOR->SetCallState(data, callState); 808 want.SetParam("state", StateType::CALL_STATUS_INCOMING); 809 data.SetWant(want); 810 callState = 0; 811 DEVICE_MONITOR->SetCallState(data, callState); 812 813 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 814 keyEvent->SetKeyCode(KeyEvent::KEYCODE_VOLUME_UP); 815 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 816 } 817 818 /** 819 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_004 820 * @tc.desc: Test ring mute 821 * @tc.type: FUNC 822 * @tc.require: 823 */ 824 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_004, TestSize.Level1) 825 { 826 CALL_TEST_DEBUG; 827 KeySubscriberHandler keySubscriberHandler; 828 OHOS::EventFwk::Want want; 829 want.SetParam("state", StateType::CALL_STATUS_DISCONNECTED); 830 OHOS::EventFwk::CommonEventData data; 831 data.SetWant(want); 832 int callState = 0; 833 DEVICE_MONITOR->SetCallState(data, callState); 834 want.SetParam("state", StateType::CALL_STATUS_INCOMING); 835 data.SetWant(want); 836 callState = 0; 837 DEVICE_MONITOR->SetCallState(data, callState); 838 839 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 840 keyEvent->SetKeyCode(KeyEvent::KEYCODE_F1); 841 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 842 } 843 844 /** 845 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_005 846 * @tc.desc: Test ring mute 847 * @tc.type: FUNC 848 * @tc.require: 849 */ 850 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_005, TestSize.Level1) 851 { 852 CALL_TEST_DEBUG; 853 KeySubscriberHandler keySubscriberHandler; 854 OHOS::EventFwk::Want want; 855 want.SetParam("state", StateType::CALL_STATUS_INCOMING); 856 OHOS::EventFwk::CommonEventData data; 857 data.SetWant(want); 858 int callState = 0; 859 DEVICE_MONITOR->SetCallState(data, callState); 860 861 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 862 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 863 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 864 } 865 866 /** 867 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_006 868 * @tc.desc: Test ring mute 869 * @tc.type: FUNC 870 * @tc.require: 871 */ 872 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_006, 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_VOLUME_DOWN); 889 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 890 } 891 892 /** 893 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_007 894 * @tc.desc: Test ring mute 895 * @tc.type: FUNC 896 * @tc.require: 897 */ 898 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_007, TestSize.Level1) 899 { 900 CALL_TEST_DEBUG; 901 KeySubscriberHandler keySubscriberHandler; 902 OHOS::EventFwk::Want want; 903 want.SetParam("state", StateType::CALL_STATUS_DISCONNECTED); 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_008 916 * @tc.desc: Test ring mute 917 * @tc.type: FUNC 918 * @tc.require: 919 */ 920 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_008, TestSize.Level1) 921 { 922 CALL_TEST_DEBUG; 923 KeySubscriberHandler keySubscriberHandler; 924 925 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 926 keyEvent->SetKeyCode(KeyEvent::KEYCODE_VOLUME_DOWN); 927 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 928 } 929 930 /** 931 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_009 932 * @tc.desc: Test ring mute 933 * @tc.type: FUNC 934 * @tc.require: 935 */ 936 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_009, TestSize.Level1) 937 { 938 CALL_TEST_DEBUG; 939 KeySubscriberHandler keySubscriberHandler; 940 941 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 942 keyEvent->SetKeyCode(KeyEvent::KEYCODE_VOLUME_UP); 943 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 944 } 945 946 /** 947 * @tc.name: KeySubscriberHandlerTest_SubscribeKeyEvent_002 948 * @tc.desc: Test subscribe keyEvent 949 * @tc.type: FUNC 950 * @tc.require: 951 */ 952 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_SubscribeKeyEvent_002, TestSize.Level1) 953 { 954 CALL_DEBUG_ENTER; 955 KeySubscriberHandler handler; 956 int32_t subscribeId = 1; 957 SessionPtr sess = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 958 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 959 std::set<int32_t> preKeys; 960 preKeys.insert(1); 961 keyOption->SetPreKeys(preKeys); 962 ASSERT_NE(handler.SubscribeKeyEvent(sess, subscribeId, keyOption), RET_OK); 963 964 preKeys.insert(2); 965 preKeys.insert(3); 966 preKeys.insert(4); 967 preKeys.insert(5); 968 preKeys.insert(6); 969 keyOption->SetPreKeys(preKeys); 970 ASSERT_NE(handler.SubscribeKeyEvent(sess, subscribeId, keyOption), RET_OK); 971 } 972 973 /** 974 * @tc.name: KeySubscriberHandlerTest_IsEqualKeyOption 975 * @tc.desc: Test Is Equal KeyOption 976 * @tc.type: FUNC 977 * @tc.require: 978 */ 979 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsEqualKeyOption, TestSize.Level1) 980 { 981 CALL_DEBUG_ENTER; 982 KeySubscriberHandler handler; 983 std::shared_ptr<KeyOption> newOption = std::make_shared<KeyOption>(); 984 std::shared_ptr<KeyOption> oldOption = std::make_shared<KeyOption>(); 985 std::set<int32_t> preKeys; 986 std::set<int32_t> pressedKeys; 987 preKeys.insert(1); 988 pressedKeys.insert(1); 989 newOption->SetPreKeys(preKeys); 990 oldOption->SetPreKeys(pressedKeys); 991 newOption->SetFinalKey(1); 992 oldOption->SetFinalKey(2); 993 ASSERT_FALSE(handler.IsEqualKeyOption(newOption, oldOption)); 994 995 oldOption->SetFinalKey(1); 996 newOption->SetFinalKeyDown(true); 997 oldOption->SetFinalKeyDown(false); 998 ASSERT_FALSE(handler.IsEqualKeyOption(newOption, oldOption)); 999 oldOption->SetFinalKeyDown(true); 1000 1001 newOption->SetFinalKeyDownDuration(100); 1002 oldOption->SetFinalKeyDownDuration(150); 1003 ASSERT_FALSE(handler.IsEqualKeyOption(newOption, oldOption)); 1004 oldOption->SetFinalKeyDownDuration(100); 1005 1006 newOption->SetFinalKeyUpDelay(100); 1007 oldOption->SetFinalKeyUpDelay(150); 1008 ASSERT_FALSE(handler.IsEqualKeyOption(newOption, oldOption)); 1009 oldOption->SetFinalKeyUpDelay(100); 1010 ASSERT_TRUE(handler.IsEqualKeyOption(newOption, oldOption)); 1011 } 1012 1013 /** 1014 * @tc.name: KeySubscriberHandlerTest_IsEnableCombineKey_003 1015 * @tc.desc: Test Is Enable CombineKey 1016 * @tc.type: FUNC 1017 * @tc.require: 1018 */ 1019 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsEnableCombineKey_003, TestSize.Level1) 1020 { 1021 CALL_DEBUG_ENTER; 1022 KeySubscriberHandler handler; 1023 KeyEvent::KeyItem item; 1024 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1025 handler.enableCombineKey_ = false; 1026 keyEvent->SetKeyCode(KeyEvent::KEYCODE_BRIGHTNESS_DOWN); 1027 item.SetKeyCode(KeyEvent::KEYCODE_A); 1028 keyEvent->AddKeyItem(item); 1029 ASSERT_TRUE(handler.IsEnableCombineKey(keyEvent)); 1030 1031 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 1032 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_UP); 1033 ASSERT_TRUE(handler.IsEnableCombineKey(keyEvent)); 1034 1035 item.SetKeyCode(KeyEvent::KEYCODE_B); 1036 keyEvent->AddKeyItem(item); 1037 ASSERT_FALSE(handler.IsEnableCombineKey(keyEvent)); 1038 1039 keyEvent->SetKeyCode(KeyEvent::KEYCODE_DPAD_RIGHT); 1040 ASSERT_FALSE(handler.IsEnableCombineKey(keyEvent)); 1041 1042 keyEvent->SetKeyCode(KeyEvent::KEYCODE_L); 1043 ASSERT_FALSE(handler.IsEnableCombineKey(keyEvent)); 1044 } 1045 1046 /** 1047 * @tc.name: KeySubscriberHandlerTest_IsEnableCombineKey_004 1048 * @tc.desc: Test Is Enable CombineKey 1049 * @tc.type: FUNC 1050 * @tc.require: 1051 */ 1052 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsEnableCombineKey_004, TestSize.Level1) 1053 { 1054 CALL_DEBUG_ENTER; 1055 KeySubscriberHandler handler; 1056 KeyEvent::KeyItem item; 1057 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1058 ASSERT_NE(keyEvent, nullptr); 1059 handler.enableCombineKey_ = false; 1060 keyEvent->SetKeyCode(KeyEvent::KEYCODE_L); 1061 item.SetKeyCode(KeyEvent::KEYCODE_L); 1062 keyEvent->AddKeyItem(item); 1063 ASSERT_TRUE(handler.IsEnableCombineKey(keyEvent)); 1064 } 1065 1066 /** 1067 * @tc.name: KeySubscriberHandlerTest_IsEnableCombineKey_005 1068 * @tc.desc: Test Is Enable CombineKey 1069 * @tc.type: FUNC 1070 * @tc.require: 1071 */ 1072 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsEnableCombineKey_005, TestSize.Level1) 1073 { 1074 CALL_DEBUG_ENTER; 1075 KeySubscriberHandler handler; 1076 KeyEvent::KeyItem item; 1077 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1078 ASSERT_NE(keyEvent, nullptr); 1079 handler.enableCombineKey_ = false; 1080 keyEvent->SetKeyCode(KeyEvent::KEYCODE_L); 1081 item.SetKeyCode(KeyEvent::KEYCODE_META_LEFT); 1082 keyEvent->AddKeyItem(item); 1083 ASSERT_TRUE(handler.IsEnableCombineKey(keyEvent)); 1084 } 1085 1086 /** 1087 * @tc.name: KeySubscriberHandlerTest_IsEnableCombineKey_006 1088 * @tc.desc: Test Is Enable CombineKey 1089 * @tc.type: FUNC 1090 * @tc.require: 1091 */ 1092 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsEnableCombineKey_006, TestSize.Level1) 1093 { 1094 CALL_DEBUG_ENTER; 1095 KeySubscriberHandler handler; 1096 KeyEvent::KeyItem item; 1097 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1098 ASSERT_NE(keyEvent, nullptr); 1099 handler.enableCombineKey_ = false; 1100 keyEvent->SetKeyCode(KeyEvent::KEYCODE_L); 1101 item.SetKeyCode(KeyEvent::KEYCODE_META_RIGHT); 1102 keyEvent->AddKeyItem(item); 1103 ASSERT_TRUE(handler.IsEnableCombineKey(keyEvent)); 1104 } 1105 1106 /** 1107 * @tc.name: KeySubscriberHandlerTest_RemoveSubscriber 1108 * @tc.desc: Test Remove Subscriber 1109 * @tc.type: FUNC 1110 * @tc.require: 1111 */ 1112 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_RemoveSubscriber, TestSize.Level1) 1113 { 1114 CALL_DEBUG_ENTER; 1115 KeySubscriberHandler handler; 1116 int32_t subscribeId = 2; 1117 int32_t id = 1; 1118 std::list<std::shared_ptr<KeySubscriberHandler::Subscriber>> subscriberList; 1119 SessionPtr session = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 1120 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 1121 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 1122 std::make_shared<KeySubscriberHandler::Subscriber>(id, session, keyOption); 1123 subscriberList.push_back(subscriber); 1124 handler.subscriberMap_.insert(std::make_pair(keyOption, subscriberList)); 1125 ASSERT_EQ(handler.RemoveSubscriber(session, subscribeId, true), RET_ERR); 1126 subscribeId = 1; 1127 ASSERT_EQ(handler.RemoveSubscriber(session, subscribeId, true), RET_OK); 1128 } 1129 1130 /** 1131 * @tc.name: KeySubscriberHandlerTest_IsFunctionKey 1132 * @tc.desc: Test IsFunctionKey 1133 * @tc.type: FUNC 1134 * @tc.require: 1135 */ 1136 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsFunctionKey, TestSize.Level1) 1137 { 1138 CALL_DEBUG_ENTER; 1139 KeySubscriberHandler handler; 1140 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1141 ASSERT_NE(keyEvent, nullptr); 1142 keyEvent->SetKeyCode(KeyEvent::KEYCODE_BRIGHTNESS_UP); 1143 ASSERT_TRUE(handler.IsFunctionKey(keyEvent)); 1144 keyEvent->SetKeyCode(KeyEvent::KEYCODE_VOLUME_UP); 1145 ASSERT_TRUE(handler.IsFunctionKey(keyEvent)); 1146 keyEvent->SetKeyCode(KeyEvent::KEYCODE_VOLUME_DOWN); 1147 ASSERT_TRUE(handler.IsFunctionKey(keyEvent)); 1148 keyEvent->SetKeyCode(KeyEvent::KEYCODE_VOLUME_MUTE); 1149 ASSERT_TRUE(handler.IsFunctionKey(keyEvent)); 1150 keyEvent->SetKeyCode(KeyEvent::KEYCODE_MUTE); 1151 ASSERT_TRUE(handler.IsFunctionKey(keyEvent)); 1152 keyEvent->SetKeyCode(KeyEvent::KEYCODE_SWITCHVIDEOMODE); 1153 ASSERT_TRUE(handler.IsFunctionKey(keyEvent)); 1154 keyEvent->SetKeyCode(KeyEvent::KEYCODE_WLAN); 1155 ASSERT_FALSE(handler.IsFunctionKey(keyEvent)); 1156 keyEvent->SetKeyCode(KeyEvent::KEYCODE_CONFIG); 1157 ASSERT_FALSE(handler.IsFunctionKey(keyEvent)); 1158 } 1159 1160 /** 1161 * @tc.name: KeySubscriberHandlerTest_OnSubscribeKeyEvent 1162 * @tc.desc: Test OnSubscribeKeyEvent 1163 * @tc.type: FUNC 1164 * @tc.require: 1165 */ 1166 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_OnSubscribeKeyEvent, TestSize.Level1) 1167 { 1168 CALL_DEBUG_ENTER; 1169 KeySubscriberHandler handler; 1170 KeyEvent::KeyItem item; 1171 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1172 ASSERT_NE(keyEvent, nullptr); 1173 handler.enableCombineKey_ = false; 1174 keyEvent->SetKeyCode(KeyEvent::KEYCODE_BRIGHTNESS_DOWN); 1175 item.SetKeyCode(KeyEvent::KEYCODE_A); 1176 keyEvent->AddKeyItem(item); 1177 item.SetKeyCode(KeyEvent::KEYCODE_B); 1178 keyEvent->AddKeyItem(item); 1179 ASSERT_FALSE(handler.OnSubscribeKeyEvent(keyEvent)); 1180 1181 handler.enableCombineKey_ = true; 1182 handler.hasEventExecuting_ = true; 1183 handler.keyEvent_ = KeyEvent::Create(); 1184 ASSERT_NE(handler.keyEvent_, nullptr); 1185 handler.keyEvent_->SetKeyCode(KeyEvent::KEYCODE_BRIGHTNESS_DOWN); 1186 handler.keyEvent_->SetKeyAction(KeyEvent::KEY_ACTION_UP); 1187 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_UP); 1188 item.SetKeyCode(KeyEvent::KEYCODE_A); 1189 handler.keyEvent_->AddKeyItem(item); 1190 item.SetKeyCode(KeyEvent::KEYCODE_B); 1191 handler.keyEvent_->AddKeyItem(item); 1192 ASSERT_TRUE(handler.OnSubscribeKeyEvent(keyEvent)); 1193 1194 handler.hasEventExecuting_ = false; 1195 handler.needSkipPowerKeyUp_ = true; 1196 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 1197 ASSERT_TRUE(handler.OnSubscribeKeyEvent(keyEvent)); 1198 1199 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_UNKNOWN); 1200 ASSERT_FALSE(handler.OnSubscribeKeyEvent(keyEvent)); 1201 } 1202 1203 /** 1204 * @tc.name: KeySubscriberHandlerTest_OnSessionDelete 1205 * @tc.desc: Test OnSessionDelete 1206 * @tc.type: FUNC 1207 * @tc.require: 1208 */ 1209 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_OnSessionDelete, TestSize.Level1) 1210 { 1211 CALL_DEBUG_ENTER; 1212 KeySubscriberHandler handler; 1213 int32_t id = 1; 1214 std::list<std::shared_ptr<KeySubscriberHandler::Subscriber>> subscriberList; 1215 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 1216 SessionPtr session = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 1217 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 1218 std::make_shared<KeySubscriberHandler::Subscriber>(id, session, keyOption); 1219 subscriberList.push_back(subscriber); 1220 handler.subscriberMap_.insert(std::make_pair(keyOption, subscriberList)); 1221 SessionPtr sess = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 1222 ASSERT_NO_FATAL_FAILURE(handler.OnSessionDelete(sess)); 1223 ASSERT_NO_FATAL_FAILURE(handler.OnSessionDelete(session)); 1224 } 1225 1226 /** 1227 * @tc.name: KeySubscriberHandlerTest_IsPreKeysMatch 1228 * @tc.desc: Test IsPreKeysMatch 1229 * @tc.type: FUNC 1230 * @tc.require: 1231 */ 1232 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsPreKeysMatch, TestSize.Level1) 1233 { 1234 CALL_DEBUG_ENTER; 1235 KeySubscriberHandler handler; 1236 std::set<int32_t> preKeys; 1237 std::vector<int32_t> pressedKeys; 1238 preKeys.insert(KeyEvent::KEYCODE_A); 1239 pressedKeys.push_back(KeyEvent::KEYCODE_B); 1240 ASSERT_FALSE(handler.IsPreKeysMatch(preKeys, pressedKeys)); 1241 preKeys.clear(); 1242 pressedKeys.clear(); 1243 preKeys.insert(KeyEvent::KEYCODE_C); 1244 pressedKeys.push_back(KeyEvent::KEYCODE_C); 1245 ASSERT_TRUE(handler.IsPreKeysMatch(preKeys, pressedKeys)); 1246 } 1247 1248 /** 1249 * @tc.name: KeySubscriberHandlerTest_IsMatchForegroundPid 1250 * @tc.desc: Test Is Match Foreground Pid 1251 * @tc.type: FUNC 1252 * @tc.require: 1253 */ 1254 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsMatchForegroundPid, TestSize.Level1) 1255 { 1256 CALL_DEBUG_ENTER; 1257 KeySubscriberHandler handler; 1258 int32_t id = 1; 1259 SessionPtr session = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 1260 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 1261 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 1262 std::make_shared<KeySubscriberHandler::Subscriber>(id, session, keyOption); 1263 std::list<std::shared_ptr<KeySubscriberHandler::Subscriber>> subscriberList; 1264 std::set<int32_t> foregroundPids; 1265 subscriberList.push_back(subscriber); 1266 foregroundPids.insert(1); 1267 ASSERT_FALSE(handler.IsMatchForegroundPid(subscriberList, foregroundPids)); 1268 1269 foregroundPids.insert(100); 1270 ASSERT_TRUE(handler.IsMatchForegroundPid(subscriberList, foregroundPids)); 1271 } 1272 1273 /** 1274 * @tc.name: KeySubscriberHandlerTest_NotifyKeyDownSubscriber 1275 * @tc.desc: Test Notify Key Down Subscriber 1276 * @tc.type: FUNC 1277 * @tc.require: 1278 */ 1279 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifyKeyDownSubscriber, TestSize.Level1) 1280 { 1281 CALL_DEBUG_ENTER; 1282 KeySubscriberHandler handler; 1283 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1284 ASSERT_NE(keyEvent, nullptr); 1285 int32_t id = 1; 1286 bool handled = false; 1287 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 1288 SessionPtr session = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 1289 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 1290 std::make_shared<KeySubscriberHandler::Subscriber>(id, session, keyOption); 1291 std::list<std::shared_ptr<KeySubscriberHandler::Subscriber>> subscriberList; 1292 subscriberList.push_back(subscriber); 1293 keyOption->SetFinalKeyDownDuration(100); 1294 ASSERT_NO_FATAL_FAILURE(handler.NotifyKeyDownSubscriber(keyEvent, keyOption, subscriberList, handled)); 1295 } 1296 1297 /** 1298 * @tc.name: KeySubscriberHandlerTest_NotifyKeyDownRightNow 1299 * @tc.desc: Test Notify Key Down Right Now 1300 * @tc.type: FUNC 1301 * @tc.require: 1302 */ 1303 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifyKeyDownRightNow, TestSize.Level1) 1304 { 1305 CALL_DEBUG_ENTER; 1306 KeySubscriberHandler handler; 1307 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1308 ASSERT_NE(keyEvent, nullptr); 1309 int32_t id = 1; 1310 bool handled = false; 1311 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 1312 SessionPtr session = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 1313 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 1314 std::make_shared<KeySubscriberHandler::Subscriber>(id, session, keyOption); 1315 std::list<std::shared_ptr<KeySubscriberHandler::Subscriber>> subscriberList; 1316 subscriberList.push_back(subscriber); 1317 handler.isForegroundExits_ = true; 1318 ASSERT_NO_FATAL_FAILURE(handler.NotifyKeyDownRightNow(keyEvent, subscriberList, true, handled)); 1319 1320 handler.isForegroundExits_ = false; 1321 handler.foregroundPids_.insert(UDS_PID); 1322 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 1323 ASSERT_NO_FATAL_FAILURE(handler.NotifyKeyDownRightNow(keyEvent, subscriberList, true, handled)); 1324 } 1325 1326 /** 1327 * @tc.name: KeySubscriberHandlerTest_NotifyKeyDownDelay 1328 * @tc.desc: Test Notify KeyDown Delay 1329 * @tc.type: FUNC 1330 * @tc.require: 1331 */ 1332 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifyKeyDownDelay, TestSize.Level1) 1333 { 1334 CALL_DEBUG_ENTER; 1335 KeySubscriberHandler handler; 1336 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1337 ASSERT_NE(keyEvent, nullptr); 1338 int32_t id = 1; 1339 bool handled = false; 1340 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 1341 SessionPtr session = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 1342 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 1343 std::make_shared<KeySubscriberHandler::Subscriber>(id, session, keyOption); 1344 std::list<std::shared_ptr<KeySubscriberHandler::Subscriber>> subscriberList; 1345 subscriber->timerId_ = 1; 1346 subscriberList.push_back(subscriber); 1347 handler.isForegroundExits_ = true; 1348 ASSERT_NO_FATAL_FAILURE(handler.NotifyKeyDownDelay(keyEvent, subscriberList, handled)); 1349 1350 handler.isForegroundExits_ = false; 1351 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 1352 handler.foregroundPids_.insert(UDS_PID); 1353 ASSERT_NO_FATAL_FAILURE(handler.NotifyKeyDownDelay(keyEvent, subscriberList, handled)); 1354 } 1355 1356 /** 1357 * @tc.name: KeySubscriberHandlerTest_NotifyKeyUpSubscriber 1358 * @tc.desc: Test Notify KeyUp Subscriber 1359 * @tc.type: FUNC 1360 * @tc.require: 1361 */ 1362 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifyKeyUpSubscriber, TestSize.Level1) 1363 { 1364 CALL_DEBUG_ENTER; 1365 KeySubscriberHandler handler; 1366 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1367 ASSERT_NE(keyEvent, nullptr); 1368 int32_t id = 1; 1369 bool handled = false; 1370 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 1371 SessionPtr session = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 1372 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 1373 std::make_shared<KeySubscriberHandler::Subscriber>(id, session, keyOption); 1374 std::list<std::shared_ptr<KeySubscriberHandler::Subscriber>> subscriberList; 1375 subscriber->timerId_ = 1; 1376 keyOption->SetFinalKeyUpDelay(1000); 1377 subscriberList.push_back(subscriber); 1378 ASSERT_NO_FATAL_FAILURE(handler.NotifyKeyUpSubscriber(keyEvent, subscriberList, handled)); 1379 handler.isForegroundExits_ = true; 1380 handler.foregroundPids_.insert(UDS_PID); 1381 ASSERT_NO_FATAL_FAILURE(handler.NotifyKeyUpSubscriber(keyEvent, subscriberList, handled)); 1382 handler.foregroundPids_.erase(UDS_PID); 1383 ASSERT_NO_FATAL_FAILURE(handler.NotifyKeyUpSubscriber(keyEvent, subscriberList, handled)); 1384 } 1385 1386 /** 1387 * @tc.name: KeySubscriberHandlerTest_IsKeyEventSubscribed 1388 * @tc.desc: Test IsKeyEventSubscribed 1389 * @tc.type: FUNC 1390 * @tc.require: 1391 */ 1392 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsKeyEventSubscribed, TestSize.Level1) 1393 { 1394 KeySubscriberHandler handler; 1395 int32_t id = 1; 1396 int32_t keyCode = KeyEvent::KEYCODE_ALT_LEFT; 1397 int32_t trrigerType = KeyEvent::KEY_ACTION_DOWN; 1398 SessionPtr session = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 1399 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 1400 keyOption->SetFinalKeyDown(false); 1401 keyOption->SetFinalKey(KeyEvent::KEYCODE_CTRL_LEFT); 1402 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 1403 std::make_shared<KeySubscriberHandler::Subscriber>(id, session, keyOption); 1404 std::list<std::shared_ptr<KeySubscriberHandler::Subscriber>> subscriberList; 1405 subscriberList.push_back(subscriber); 1406 handler.subscriberMap_.insert(std::make_pair(keyOption, subscriberList)); 1407 ASSERT_FALSE(handler.IsKeyEventSubscribed(keyCode, trrigerType)); 1408 1409 for (auto &iter : handler.subscriberMap_) { 1410 iter.first->SetFinalKeyDown(true); 1411 } 1412 keyCode = KeyEvent::KEYCODE_CTRL_LEFT; 1413 ASSERT_TRUE(handler.IsKeyEventSubscribed(keyCode, trrigerType)); 1414 } 1415 1416 /** 1417 * @tc.name: KeySubscriberHandlerTest_RemoveKeyCode 1418 * @tc.desc: Test RemoveKeyCode 1419 * @tc.type: FUNC 1420 * @tc.require: 1421 */ 1422 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_RemoveKeyCode, TestSize.Level1) 1423 { 1424 KeySubscriberHandler handler; 1425 int32_t keyCode = KeyEvent::KEYCODE_A; 1426 std::vector<int32_t> keyCodes { KeyEvent::KEYCODE_A, KeyEvent::KEYCODE_B }; 1427 ASSERT_NO_FATAL_FAILURE(handler.RemoveKeyCode(keyCode, keyCodes)); 1428 keyCode = KeyEvent::KEYCODE_C; 1429 ASSERT_NO_FATAL_FAILURE(handler.RemoveKeyCode(keyCode, keyCodes)); 1430 } 1431 1432 /** 1433 * @tc.name: KeySubscriberHandlerTest_IsRepeatedKeyEvent 1434 * @tc.desc: Test IsRepeatedKeyEvent 1435 * @tc.type: FUNC 1436 * @tc.require: 1437 */ 1438 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsRepeatedKeyEvent, TestSize.Level1) 1439 { 1440 KeySubscriberHandler handler; 1441 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1442 ASSERT_NE(keyEvent, nullptr); 1443 ASSERT_FALSE(handler.IsRepeatedKeyEvent(keyEvent)); 1444 handler.keyEvent_ = KeyEvent::Create(); 1445 ASSERT_NE(keyEvent, nullptr); 1446 handler.hasEventExecuting_ = true; 1447 handler.keyEvent_->SetKeyCode(KeyEvent::KEYCODE_A); 1448 keyEvent->SetKeyCode(KeyEvent::KEYCODE_B); 1449 ASSERT_FALSE(handler.IsRepeatedKeyEvent(keyEvent)); 1450 keyEvent->SetKeyCode(KeyEvent::KEYCODE_A); 1451 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_UP); 1452 handler.keyEvent_->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 1453 ASSERT_FALSE(handler.IsRepeatedKeyEvent(keyEvent)); 1454 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 1455 KeyEvent::KeyItem item; 1456 item.SetKeyCode(KeyEvent::KEYCODE_A); 1457 handler.keyEvent_->AddKeyItem(item); 1458 ASSERT_FALSE(handler.IsRepeatedKeyEvent(keyEvent)); 1459 item.SetKeyCode(KeyEvent::KEYCODE_B); 1460 keyEvent->AddKeyItem(item); 1461 ASSERT_FALSE(handler.IsRepeatedKeyEvent(keyEvent)); 1462 item.SetKeyCode(KeyEvent::KEYCODE_B); 1463 handler.keyEvent_->AddKeyItem(item); 1464 item.SetKeyCode(KeyEvent::KEYCODE_D); 1465 keyEvent->AddKeyItem(item); 1466 ASSERT_FALSE(handler.IsRepeatedKeyEvent(keyEvent)); 1467 } 1468 1469 /** 1470 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_010 1471 * @tc.desc: Test the funcation HandleRingMute 1472 * @tc.type: FUNC 1473 * @tc.require: 1474 */ 1475 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_010, TestSize.Level1) 1476 { 1477 CALL_TEST_DEBUG; 1478 KeySubscriberHandler handler; 1479 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1480 ASSERT_NE(keyEvent, nullptr); 1481 keyEvent->SetKeyCode(KeyEvent::KEYCODE_VOLUME_DOWN); 1482 OHOS::EventFwk::Want want; 1483 want.SetParam("state", StateType::CALL_STATUS_INCOMING); 1484 OHOS::EventFwk::CommonEventData data; 1485 data.SetWant(want); 1486 int32_t callState = 0; 1487 DEVICE_MONITOR->SetCallState(data, callState); 1488 DeviceEventMonitor monitor; 1489 monitor.hasHandleRingMute_ = false; 1490 bool ret = handler.HandleRingMute(keyEvent); 1491 ASSERT_FALSE(ret); 1492 monitor.hasHandleRingMute_ = true; 1493 ret = handler.HandleRingMute(keyEvent); 1494 ASSERT_FALSE(ret); 1495 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 1496 ret = handler.HandleRingMute(keyEvent); 1497 ASSERT_FALSE(ret); 1498 want.SetParam("state", StateType::CALL_STATUS_ALERTING); 1499 data.SetWant(want); 1500 DEVICE_MONITOR->SetCallState(data, callState); 1501 ret = handler.HandleRingMute(keyEvent); 1502 ASSERT_FALSE(ret); 1503 } 1504 1505 /** 1506 * @tc.name: KeySubscriberHandlerTest_OnSubscribeKeyEvent_002 1507 * @tc.desc: Test the funcation OnSubscribeKeyEvent 1508 * @tc.type: FUNC 1509 * @tc.require: 1510 */ 1511 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_OnSubscribeKeyEvent_002, TestSize.Level1) 1512 { 1513 CALL_TEST_DEBUG; 1514 KeySubscriberHandler handler; 1515 OHOS::EventFwk::Want want; 1516 want.SetParam("state", StateType::CALL_STATUS_DISCONNECTED); 1517 OHOS::EventFwk::CommonEventData data; 1518 data.SetWant(want); 1519 int callState = 0; 1520 DEVICE_MONITOR->SetCallState(data, callState); 1521 want.SetParam("state", StateType::CALL_STATUS_INCOMING); 1522 data.SetWant(want); 1523 callState = 0; 1524 DEVICE_MONITOR->SetCallState(data, callState); 1525 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1526 keyEvent->SetKeyCode(KeyEvent::KEYCODE_VOLUME_UP); 1527 bool ret = handler.OnSubscribeKeyEvent(keyEvent); 1528 ASSERT_FALSE(ret); 1529 } 1530 1531 /** 1532 * @tc.name: KeySubscriberHandlerTest_OnSubscribeKeyEvent_003 1533 * @tc.desc: Test the funcation OnSubscribeKeyEvent 1534 * @tc.type: FUNC 1535 * @tc.require: 1536 */ 1537 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_OnSubscribeKeyEvent_003, TestSize.Level1) 1538 { 1539 CALL_TEST_DEBUG; 1540 KeySubscriberHandler handler; 1541 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1542 ASSERT_NE(keyEvent, nullptr); 1543 handler.needSkipPowerKeyUp_ = true; 1544 KeyEvent::KeyItem item; 1545 item.SetKeyCode(KeyEvent::KEYCODE_POWER); 1546 keyEvent->AddKeyItem(item); 1547 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 1548 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_UP); 1549 ASSERT_TRUE(handler.OnSubscribeKeyEvent(keyEvent)); 1550 } 1551 1552 /** 1553 * @tc.name: KeySubscriberHandlerTest_NotifySubscriber_002 1554 * @tc.desc: Test the funcation NotifySubscriber 1555 * @tc.type: FUNC 1556 * @tc.require: 1557 */ 1558 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifySubscriber_002, TestSize.Level1) 1559 { 1560 CALL_TEST_DEBUG; 1561 KeySubscriberHandler handler; 1562 SessionPtr sess; 1563 std::shared_ptr<KeyOption> keyOption; 1564 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1565 ASSERT_NE(keyEvent, nullptr); 1566 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 1567 KeyEvent::KeyItem item; 1568 item.SetKeyCode(KeyEvent::KEYCODE_POWER); 1569 keyEvent->AddKeyItem(item); 1570 keyEvent->SetKeyCode(KeyEvent::KEYCODE_CAMERA); 1571 ASSERT_NO_FATAL_FAILURE(handler.NotifySubscriber(keyEvent, subscriber)); 1572 } 1573 1574 /** 1575 * @tc.name: KeySubscriberHandlerTest_AddTimer_001 1576 * @tc.desc: Test the funcation AddTimer 1577 * @tc.type: FUNC 1578 * @tc.require: 1579 */ 1580 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_AddTimer_001, TestSize.Level1) 1581 { 1582 CALL_TEST_DEBUG; 1583 KeySubscriberHandler handler; 1584 int32_t id = 1; 1585 SessionPtr session = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 1586 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 1587 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 1588 std::make_shared<KeySubscriberHandler::Subscriber>(id, session, keyOption); 1589 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1590 ASSERT_NE(keyEvent, nullptr); 1591 subscriber->timerId_ = 1; 1592 bool ret = handler.AddTimer(subscriber, keyEvent); 1593 ASSERT_TRUE(ret); 1594 subscriber->timerId_ = -1; 1595 keyOption->isFinalKeyDown_ = true; 1596 ret = handler.AddTimer(subscriber, keyEvent); 1597 ASSERT_TRUE(ret); 1598 keyOption->isFinalKeyDown_ = false; 1599 ret = handler.AddTimer(subscriber, keyEvent); 1600 ASSERT_TRUE(ret); 1601 } 1602 1603 /** 1604 * @tc.name: KeySubscriberHandlerTest_HandleKeyDown_002 1605 * @tc.desc: Test the funcation HandleKeyDown 1606 * @tc.type: FUNC 1607 * @tc.require: 1608 */ 1609 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleKeyDown_002, TestSize.Level1) 1610 { 1611 CALL_DEBUG_ENTER; 1612 KeySubscriberHandler handler; 1613 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1614 ASSERT_NE(keyEvent, nullptr); 1615 auto keyOption = std::make_shared<KeyOption>(); 1616 keyOption->isFinalKeyDown_ = false; 1617 SessionPtr sess; 1618 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 1619 std::list<std::shared_ptr<OHOS::MMI::KeySubscriberHandler::Subscriber>> subscribers; 1620 subscribers.push_back(subscriber); 1621 handler.subscriberMap_.insert(std::make_pair(keyOption, subscribers)); 1622 bool ret = handler.HandleKeyDown(keyEvent); 1623 ASSERT_FALSE(ret); 1624 keyOption->isFinalKeyDown_ = true; 1625 keyOption->finalKey_ = true; 1626 subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 1627 subscribers.push_back(subscriber); 1628 handler.subscriberMap_.insert(std::make_pair(keyOption, subscribers)); 1629 KeyEvent::KeyItem item; 1630 item.SetKeyCode(KeyEvent::KEYCODE_POWER); 1631 keyEvent->AddKeyItem(item); 1632 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 1633 ret = handler.HandleKeyDown(keyEvent); 1634 ASSERT_FALSE(ret); 1635 keyOption->finalKey_ = false; 1636 std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 1637 subscribers.push_back(subscriber); 1638 handler.subscriberMap_.insert(std::make_pair(keyOption, subscribers)); 1639 ret = handler.HandleKeyDown(keyEvent); 1640 ASSERT_FALSE(ret); 1641 keyEvent->SetKeyCode(KeyEvent::KEYCODE_CAMERA); 1642 ret = handler.HandleKeyDown(keyEvent); 1643 ASSERT_FALSE(ret); 1644 } 1645 1646 /** 1647 * @tc.name: KeySubscriberHandlerTest_HandleKeyUp_002 1648 * @tc.desc: Test the funcation HandleKeyUp 1649 * @tc.type: FUNC 1650 * @tc.require: 1651 */ 1652 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleKeyUp_002, TestSize.Level1) 1653 { 1654 CALL_DEBUG_ENTER; 1655 KeySubscriberHandler handler; 1656 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1657 ASSERT_NE(keyEvent, nullptr); 1658 auto keyOption = std::make_shared<KeyOption>(); 1659 keyOption->isFinalKeyDown_ = true; 1660 SessionPtr sess; 1661 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 1662 std::list<std::shared_ptr<OHOS::MMI::KeySubscriberHandler::Subscriber>> subscribers; 1663 subscribers.push_back(subscriber); 1664 handler.subscriberMap_.insert(std::make_pair(keyOption, subscribers)); 1665 bool ret = handler.HandleKeyUp(keyEvent); 1666 ASSERT_FALSE(ret); 1667 keyOption->isFinalKeyDown_ = false; 1668 keyOption->finalKey_ = 2; 1669 std::set<int32_t> tmp; 1670 for (auto i = 0; i < 5; i++) { 1671 tmp.insert(i); 1672 KeyEvent::KeyItem keyItem; 1673 keyItem.pressed_ = true; 1674 keyItem.SetKeyCode(i); 1675 keyItem.downTime_ = 2000; 1676 keyEvent->keys_.push_back(keyItem); 1677 } 1678 tmp.clear(); 1679 keyOption->SetPreKeys(tmp); 1680 keyOption->finalKeyDownDuration_ = 0; 1681 keyOption->finalKey_ = -1; 1682 keyEvent->SetKeyCode(-1); 1683 subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 1684 subscribers.push_back(subscriber); 1685 handler.subscriberMap_.insert(std::make_pair(keyOption, subscribers)); 1686 KEY_SHORTCUT_MGR->isCheckShortcut_ = true; 1687 ret = handler.HandleKeyUp(keyEvent); 1688 ASSERT_FALSE(ret); 1689 keyOption->finalKeyDownDuration_ = 3; 1690 keyOption->finalKey_ = 3; 1691 keyEvent->SetKeyCode(3); 1692 subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 1693 subscribers.push_back(subscriber); 1694 handler.subscriberMap_.insert(std::make_pair(keyOption, subscribers)); 1695 KEY_SHORTCUT_MGR->isCheckShortcut_ = true; 1696 ret = handler.HandleKeyUp(keyEvent); 1697 ASSERT_FALSE(ret); 1698 } 1699 1700 /** 1701 * @tc.name: KeySubscriberHandlerTest_HandleKeyUp_003 1702 * @tc.desc: Test the funcation HandleKeyUp 1703 * @tc.type: FUNC 1704 * @tc.require: 1705 */ 1706 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleKeyUp_003, TestSize.Level1) 1707 { 1708 CALL_DEBUG_ENTER; 1709 KeySubscriberHandler handler; 1710 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1711 ASSERT_NE(keyEvent, nullptr); 1712 auto keyOption = std::make_shared<KeyOption>(); 1713 keyOption->isFinalKeyDown_ = false; 1714 SessionPtr sess; 1715 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 1716 std::list<std::shared_ptr<OHOS::MMI::KeySubscriberHandler::Subscriber>> subscribers; 1717 keyOption->finalKey_ = 0; 1718 subscribers.push_back(subscriber); 1719 handler.subscriberMap_.insert(std::make_pair(keyOption, subscribers)); 1720 KEY_SHORTCUT_MGR->isCheckShortcut_ = true; 1721 keyEvent->SetKeyCode(-1); 1722 bool ret = false; 1723 ret = handler.HandleKeyUp(keyEvent); 1724 ASSERT_FALSE(ret); 1725 keyOption->finalKey_ = 2; 1726 std::set<int32_t> tmp; 1727 for (auto i = 0; i < 5; i++) { 1728 tmp.insert(i); 1729 KeyEvent::KeyItem keyItem; 1730 keyItem.pressed_ = true; 1731 keyItem.SetKeyCode(i); 1732 keyItem.downTime_ = 2000; 1733 keyEvent->keys_.push_back(keyItem); 1734 } 1735 keyOption->SetPreKeys(tmp); 1736 subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 1737 subscribers.push_back(subscriber); 1738 handler.subscriberMap_.insert(std::make_pair(keyOption, subscribers)); 1739 keyEvent->SetKeyCode(2); 1740 KEY_SHORTCUT_MGR->isCheckShortcut_ = true; 1741 ret = handler.HandleKeyUp(keyEvent); 1742 ASSERT_FALSE(ret); 1743 tmp.clear(); 1744 keyOption->SetPreKeys(tmp); 1745 keyOption->finalKey_ = 4; 1746 keyEvent->SetKeyCode(4); 1747 keyEvent->actionTime_ = 3000; 1748 keyOption->finalKeyDownDuration_ = 3; 1749 subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 1750 subscribers.push_back(subscriber); 1751 handler.subscriberMap_.insert(std::make_pair(keyOption, subscribers)); 1752 KEY_SHORTCUT_MGR->isCheckShortcut_ = true; 1753 ret = handler.HandleKeyUp(keyEvent); 1754 ASSERT_FALSE(ret); 1755 } 1756 1757 /** 1758 * @tc.name: KeySubscriberHandlerTest_HandleKeyUp_004 1759 * @tc.desc: Test the funcation HandleKeyUp 1760 * @tc.type: FUNC 1761 * @tc.require: 1762 */ 1763 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleKeyUp_004, TestSize.Level1) 1764 { 1765 CALL_DEBUG_ENTER; 1766 KeySubscriberHandler handler; 1767 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1768 ASSERT_NE(keyEvent, nullptr); 1769 auto keyOption = std::make_shared<KeyOption>(); 1770 keyOption->isFinalKeyDown_ = true; 1771 SessionPtr sess; 1772 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 1773 std::list<std::shared_ptr<OHOS::MMI::KeySubscriberHandler::Subscriber>> subscribers; 1774 subscribers.push_back(subscriber); 1775 handler.subscriberMap_.insert(std::make_pair(keyOption, subscribers)); 1776 bool ret = handler.HandleKeyUp(keyEvent); 1777 ASSERT_FALSE(ret); 1778 } 1779 /** 1780 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_01 1781 * @tc.desc: Test the funcation HandleRingMute 1782 * @tc.type: FUNC 1783 * @tc.require: 1784 */ 1785 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_01, TestSize.Level1) 1786 { 1787 CALL_TEST_DEBUG; 1788 KeySubscriberHandler handler; 1789 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1790 ASSERT_NE(keyEvent, nullptr); 1791 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 1792 DeviceEventMonitor monitor; 1793 monitor.callState_ = StateType::CALL_STATUS_INCOMING; 1794 bool ret = handler.HandleRingMute(keyEvent); 1795 ASSERT_FALSE(ret); 1796 handler.HandleRingMute(keyEvent); 1797 monitor.hasHandleRingMute_ = false; 1798 ret = handler.HandleRingMute(keyEvent); 1799 ASSERT_FALSE(ret); 1800 monitor.hasHandleRingMute_ = true; 1801 ret = handler.HandleRingMute(keyEvent); 1802 ASSERT_FALSE(ret); 1803 monitor.callState_ = StateType::CALL_STATUS_DIALING; 1804 ret = handler.HandleRingMute(keyEvent); 1805 ASSERT_FALSE(ret); 1806 } 1807 1808 /** 1809 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_02 1810 * @tc.desc: Test ring mute 1811 * @tc.type: FUNC 1812 * @tc.require: 1813 */ 1814 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_02, TestSize.Level1) 1815 { 1816 CALL_TEST_DEBUG; 1817 KeySubscriberHandler keySubscriberHandler; 1818 1819 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1820 ASSERT_NE(keyEvent, nullptr); 1821 keyEvent->keyCode_ = KeyEvent::KEYCODE_VOLUME_DOWN; 1822 1823 DEVICE_MONITOR->callState_ = StateType::CALL_STATUS_INCOMING; 1824 auto callManagerClientPtr = DelayedSingleton<OHOS::Telephony::CallManagerClient>::GetInstance(); 1825 callManagerClientPtr = nullptr; 1826 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 1827 } 1828 1829 /** 1830 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_03 1831 * @tc.desc: Test ring mute 1832 * @tc.type: FUNC 1833 * @tc.require: 1834 */ 1835 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_03, TestSize.Level1) 1836 { 1837 CALL_TEST_DEBUG; 1838 KeySubscriberHandler keySubscriberHandler; 1839 1840 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1841 ASSERT_NE(keyEvent, nullptr); 1842 keyEvent->keyCode_ = KeyEvent::KEYCODE_VOLUME_DOWN; 1843 1844 DEVICE_MONITOR->callState_ = StateType::CALL_STATUS_INCOMING; 1845 auto callManagerClientPtr = DelayedSingleton<OHOS::Telephony::CallManagerClient>::GetInstance(); 1846 EXPECT_NE(callManagerClientPtr, nullptr); 1847 DEVICE_MONITOR->hasHandleRingMute_ = false; 1848 auto ret = callManagerClientPtr->MuteRinger(); 1849 EXPECT_NE(ret, ERR_OK); 1850 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 1851 } 1852 1853 /** 1854 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_04 1855 * @tc.desc: Test ring mute 1856 * @tc.type: FUNC 1857 * @tc.require: 1858 */ 1859 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_04, TestSize.Level1) 1860 { 1861 CALL_TEST_DEBUG; 1862 KeySubscriberHandler keySubscriberHandler; 1863 1864 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1865 ASSERT_NE(keyEvent, nullptr); 1866 keyEvent->keyCode_ = KeyEvent::KEYCODE_VOLUME_DOWN; 1867 1868 DEVICE_MONITOR->callState_ = StateType::CALL_STATUS_INCOMING; 1869 auto callManagerClientPtr = DelayedSingleton<OHOS::Telephony::CallManagerClient>::GetInstance(); 1870 EXPECT_NE(callManagerClientPtr, nullptr); 1871 DEVICE_MONITOR->hasHandleRingMute_ = false; 1872 keyEvent->keyCode_ = KeyEvent::KEYCODE_POWER; 1873 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 1874 } 1875 1876 /** 1877 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_05 1878 * @tc.desc: Test ring mute 1879 * @tc.type: FUNC 1880 * @tc.require: 1881 */ 1882 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_05, TestSize.Level1) 1883 { 1884 CALL_TEST_DEBUG; 1885 KeySubscriberHandler keySubscriberHandler; 1886 1887 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1888 ASSERT_NE(keyEvent, nullptr); 1889 keyEvent->keyCode_ = KeyEvent::KEYCODE_VOLUME_DOWN; 1890 1891 DEVICE_MONITOR->callState_ = StateType::CALL_STATUS_INCOMING; 1892 auto callManagerClientPtr = DelayedSingleton<OHOS::Telephony::CallManagerClient>::GetInstance(); 1893 EXPECT_NE(callManagerClientPtr, nullptr); 1894 DEVICE_MONITOR->hasHandleRingMute_ = false; 1895 keyEvent->keyCode_ = KeyEvent::KEYCODE_CALL; 1896 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 1897 } 1898 1899 /** 1900 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_06 1901 * @tc.desc: Test ring mute 1902 * @tc.type: FUNC 1903 * @tc.require: 1904 */ 1905 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_06, TestSize.Level1) 1906 { 1907 CALL_TEST_DEBUG; 1908 KeySubscriberHandler keySubscriberHandler; 1909 1910 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1911 ASSERT_NE(keyEvent, nullptr); 1912 keyEvent->keyCode_ = KeyEvent::KEYCODE_VOLUME_UP; 1913 1914 DEVICE_MONITOR->callState_ = StateType::CALL_STATUS_INCOMING; 1915 auto callManagerClientPtr = DelayedSingleton<OHOS::Telephony::CallManagerClient>::GetInstance(); 1916 EXPECT_NE(callManagerClientPtr, nullptr); 1917 DEVICE_MONITOR->hasHandleRingMute_ = true; 1918 keyEvent->keyCode_ = KeyEvent::KEYCODE_POWER; 1919 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 1920 } 1921 1922 /** 1923 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_07 1924 * @tc.desc: Test ring mute 1925 * @tc.type: FUNC 1926 * @tc.require: 1927 */ 1928 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_07, TestSize.Level1) 1929 { 1930 CALL_TEST_DEBUG; 1931 KeySubscriberHandler keySubscriberHandler; 1932 1933 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1934 ASSERT_NE(keyEvent, nullptr); 1935 keyEvent->keyCode_ = KeyEvent::KEYCODE_VOLUME_UP; 1936 1937 DEVICE_MONITOR->callState_ = StateType::CALL_STATUS_INCOMING; 1938 auto callManagerClientPtr = DelayedSingleton<OHOS::Telephony::CallManagerClient>::GetInstance(); 1939 EXPECT_NE(callManagerClientPtr, nullptr); 1940 DEVICE_MONITOR->hasHandleRingMute_ = true; 1941 keyEvent->keyCode_ = KeyEvent::KEYCODE_CAMERA; 1942 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 1943 } 1944 1945 /** 1946 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_08 1947 * @tc.desc: Test ring mute 1948 * @tc.type: FUNC 1949 * @tc.require: 1950 */ 1951 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_08, TestSize.Level1) 1952 { 1953 CALL_TEST_DEBUG; 1954 KeySubscriberHandler keySubscriberHandler; 1955 1956 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1957 ASSERT_NE(keyEvent, nullptr); 1958 keyEvent->keyCode_ = KeyEvent::KEYCODE_VOLUME_DOWN; 1959 1960 DEVICE_MONITOR->callState_ = StateType::CALL_STATUS_INCOMING; 1961 std::shared_ptr<OHOS::Telephony::CallManagerClient> callManagerClientPtr = nullptr; 1962 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 1963 } 1964 1965 /** 1966 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_09 1967 * @tc.desc: Test ring mute 1968 * @tc.type: FUNC 1969 * @tc.require: 1970 */ 1971 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_09, TestSize.Level1) 1972 { 1973 CALL_TEST_DEBUG; 1974 KeySubscriberHandler keySubscriberHandler; 1975 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1976 ASSERT_NE(keyEvent, nullptr); 1977 keyEvent->keyCode_ = KeyEvent::KEYCODE_VOLUME_DOWN; 1978 1979 DEVICE_MONITOR->callState_ = StateType::CALL_STATUS_INCOMING; 1980 std::shared_ptr<OHOS::Telephony::CallManagerClient> callManagerClientPtr; 1981 callManagerClientPtr = std::make_shared<OHOS::Telephony::CallManagerClient>(); 1982 EXPECT_NE(callManagerClientPtr, nullptr); 1983 DEVICE_MONITOR->hasHandleRingMute_ = false; 1984 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 1985 } 1986 1987 /** 1988 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_10 1989 * @tc.desc: Test ring mute 1990 * @tc.type: FUNC 1991 * @tc.require: 1992 */ 1993 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_10, TestSize.Level1) 1994 { 1995 CALL_TEST_DEBUG; 1996 KeySubscriberHandler keySubscriberHandler; 1997 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1998 ASSERT_NE(keyEvent, nullptr); 1999 keyEvent->keyCode_ = KeyEvent::KEYCODE_VOLUME_DOWN; 2000 2001 DEVICE_MONITOR->callState_ = StateType::CALL_STATUS_INCOMING; 2002 std::shared_ptr<OHOS::Telephony::CallManagerClient> callManagerClientPtr; 2003 callManagerClientPtr = std::make_shared<OHOS::Telephony::CallManagerClient>(); 2004 EXPECT_NE(callManagerClientPtr, nullptr); 2005 DEVICE_MONITOR->hasHandleRingMute_ = true; 2006 keyEvent->keyCode_ = KeyEvent::KEYCODE_VOLUME_UP; 2007 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 2008 } 2009 2010 /** 2011 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_11 2012 * @tc.desc: Test ring mute 2013 * @tc.type: FUNC 2014 * @tc.require: 2015 */ 2016 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_11, TestSize.Level1) 2017 { 2018 CALL_TEST_DEBUG; 2019 KeySubscriberHandler keySubscriberHandler; 2020 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 2021 ASSERT_NE(keyEvent, nullptr); 2022 keyEvent->keyCode_ = KeyEvent::KEYCODE_VOLUME_DOWN; 2023 2024 DEVICE_MONITOR->callState_ = StateType::CALL_STATUS_INCOMING; 2025 std::shared_ptr<OHOS::Telephony::CallManagerClient> callManagerClientPtr; 2026 callManagerClientPtr = std::make_shared<OHOS::Telephony::CallManagerClient>(); 2027 EXPECT_NE(callManagerClientPtr, nullptr); 2028 DEVICE_MONITOR->hasHandleRingMute_ = true; 2029 keyEvent->keyCode_ = KeyEvent::KEYCODE_POWER; 2030 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 2031 } 2032 2033 /** 2034 * @tc.name: KeySubscriberHandlerTest_AddKeyGestureSubscriber_01 2035 * @tc.desc: Test AddKeyGestureSubscriber 2036 * @tc.type: FUNC 2037 * @tc.require: 2038 */ 2039 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_AddKeyGestureSubscriber_01, TestSize.Level1) 2040 { 2041 CALL_TEST_DEBUG; 2042 KeySubscriberHandler handler; 2043 SessionPtr sess; 2044 std::shared_ptr<KeyOption> keyOption; 2045 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 2046 subscriber->timerId_ = -1; 2047 ASSERT_NO_FATAL_FAILURE(handler.AddKeyGestureSubscriber(subscriber, keyOption)); 2048 } 2049 2050 /** 2051 * @tc.name: KeySubscriberHandlerTest_AddKeyGestureSubscriber_02 2052 * @tc.desc: Test AddKeyGestureSubscriber 2053 * @tc.type: FUNC 2054 * @tc.require: 2055 */ 2056 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_AddKeyGestureSubscriber_02, TestSize.Level1) 2057 { 2058 CALL_TEST_DEBUG; 2059 KeySubscriberHandler handler; 2060 SessionPtr sess; 2061 std::shared_ptr<KeyOption> keyOption; 2062 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(3, sess, keyOption); 2063 subscriber->timerId_ = 1; 2064 2065 auto keyOption1 = std::make_shared<KeyOption>(); 2066 keyOption1->SetFinalKey(1); 2067 keyOption1->SetFinalKeyDown(true); 2068 auto keyOption2 = std::make_shared<KeyOption>(); 2069 keyOption2->SetFinalKey(1); 2070 keyOption2->SetFinalKeyDown(true); 2071 2072 std::list<std::shared_ptr<OHOS::MMI::KeySubscriberHandler::Subscriber>> subscribers; 2073 auto subscriber1 = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 2074 auto subscriber2 = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(2, sess, keyOption); 2075 subscribers.push_back(subscriber1); 2076 subscribers.push_back(subscriber2); 2077 handler.keyGestures_.insert({keyOption2, subscribers}); 2078 2079 for (auto &iter : handler.keyGestures_) { 2080 EXPECT_TRUE(handler.IsEqualKeyOption(keyOption1, iter.first)); 2081 } 2082 ASSERT_NO_FATAL_FAILURE(handler.AddKeyGestureSubscriber(subscriber, keyOption1)); 2083 } 2084 2085 /** 2086 * @tc.name: KeySubscriberHandlerTest_AddKeyGestureSubscriber_03 2087 * @tc.desc: Test AddKeyGestureSubscriber 2088 * @tc.type: FUNC 2089 * @tc.require: 2090 */ 2091 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_AddKeyGestureSubscriber_03, TestSize.Level1) 2092 { 2093 CALL_TEST_DEBUG; 2094 KeySubscriberHandler handler; 2095 SessionPtr sess; 2096 std::shared_ptr<KeyOption> keyOption; 2097 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(3, sess, keyOption); 2098 subscriber->timerId_ = 2; 2099 2100 auto keyOption1 = std::make_shared<KeyOption>(); 2101 keyOption1->SetFinalKey(2); 2102 keyOption1->SetFinalKeyDown(true); 2103 auto keyOption2 = std::make_shared<KeyOption>(); 2104 keyOption2->SetFinalKey(1); 2105 keyOption2->SetFinalKeyDown(false); 2106 2107 std::list<std::shared_ptr<OHOS::MMI::KeySubscriberHandler::Subscriber>> subscribers; 2108 auto subscriber1 = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 2109 auto subscriber2 = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(2, sess, keyOption); 2110 subscribers.push_back(subscriber1); 2111 subscribers.push_back(subscriber2); 2112 handler.keyGestures_.insert({keyOption2, subscribers}); 2113 2114 for (auto &iter : handler.keyGestures_) { 2115 EXPECT_FALSE(handler.IsEqualKeyOption(keyOption1, iter.first)); 2116 } 2117 ASSERT_NO_FATAL_FAILURE(handler.AddKeyGestureSubscriber(subscriber, keyOption1)); 2118 } 2119 2120 /** 2121 * @tc.name: KeySubscriberHandlerTest_RemoveKeyGestureSubscriber_01 2122 * @tc.desc: Test RemoveKeyGestureSubscriber 2123 * @tc.type: FUNC 2124 * @tc.require: 2125 */ 2126 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_RemoveKeyGestureSubscriber_01, TestSize.Level1) 2127 { 2128 CALL_TEST_DEBUG; 2129 KeySubscriberHandler handler; 2130 SessionPtr sess = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 2131 EXPECT_NE(sess, nullptr); 2132 2133 auto keyOption1 = std::make_shared<KeyOption>(); 2134 keyOption1->SetFinalKey(2); 2135 keyOption1->SetFinalKeyDown(true); 2136 auto keyOption2 = std::make_shared<KeyOption>(); 2137 keyOption2->SetFinalKey(1); 2138 keyOption2->SetFinalKeyDown(false); 2139 2140 std::list<std::shared_ptr<OHOS::MMI::KeySubscriberHandler::Subscriber>> subscribers; 2141 std::shared_ptr<KeyOption> keyOption; 2142 auto subscriber1 = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 2143 auto subscriber2 = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(2, sess, keyOption); 2144 subscribers.push_back(subscriber1); 2145 subscribers.push_back(subscriber2); 2146 handler.keyGestures_.insert({keyOption2, subscribers}); 2147 2148 int32_t subscribeId = 3; 2149 for (auto &iter : handler.keyGestures_) { 2150 for (auto innerIter = iter.second.begin(); innerIter != iter.second.end(); ++innerIter) { 2151 auto subscriber = *innerIter; 2152 EXPECT_TRUE(subscriber->id_ != subscribeId); 2153 EXPECT_FALSE(subscriber->sess_ != sess); 2154 } 2155 int32_t ret = handler.RemoveKeyGestureSubscriber(sess, subscribeId); 2156 EXPECT_EQ(ret, RET_ERR); 2157 } 2158 } 2159 2160 /** 2161 * @tc.name: InputWindowsManagerTest_UnsubscribeKeyEvent_01 2162 * @tc.desc: Test UnsubscribeKeyEvent 2163 * @tc.type: FUNC 2164 * @tc.require: 2165 */ 2166 HWTEST_F(KeySubscriberHandlerTest, InputWindowsManagerTest_UnsubscribeKeyEvent_01, TestSize.Level1) 2167 { 2168 CALL_TEST_DEBUG; 2169 KeySubscriberHandler keySubscriberHandler; 2170 SessionPtr sess = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 2171 EXPECT_NE(sess, nullptr); 2172 int32_t subscribeId = 2; 2173 int32_t ret1 = keySubscriberHandler.RemoveSubscriber(sess, subscribeId, true); 2174 EXPECT_EQ(ret1, RET_ERR); 2175 int32_t ret2 = keySubscriberHandler.UnsubscribeKeyEvent(sess, subscribeId); 2176 EXPECT_EQ(ret2, RET_ERR); 2177 } 2178 2179 /** 2180 * @tc.name: KeySubscriberHandlerTest_NotifySubscriber_01 2181 * @tc.desc: Test NotifySubscriber 2182 * @tc.type: FUNC 2183 * @tc.require: 2184 */ 2185 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifySubscriber_01, TestSize.Level1) 2186 { 2187 CALL_TEST_DEBUG; 2188 KeySubscriberHandler handler; 2189 SessionPtr sess = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 2190 EXPECT_NE(sess, nullptr); 2191 std::shared_ptr<KeyOption> keyOption; 2192 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 2193 EXPECT_NE(keyEvent, nullptr); 2194 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 2195 EXPECT_NE(subscriber, nullptr); 2196 keyEvent->keyCode_ = KeyEvent::KEYCODE_POWER; 2197 ASSERT_NO_FATAL_FAILURE(handler.NotifySubscriber(keyEvent, subscriber)); 2198 } 2199 2200 /** 2201 * @tc.name: KeySubscriberHandlerTest_NotifySubscriber_02 2202 * @tc.desc: Test NotifySubscriber 2203 * @tc.type: FUNC 2204 * @tc.require: 2205 */ 2206 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifySubscriber_02, TestSize.Level1) 2207 { 2208 CALL_TEST_DEBUG; 2209 KeySubscriberHandler handler; 2210 SessionPtr sess = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 2211 EXPECT_NE(sess, nullptr); 2212 std::shared_ptr<KeyOption> keyOption; 2213 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 2214 EXPECT_NE(keyEvent, nullptr); 2215 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 2216 EXPECT_NE(subscriber, nullptr); 2217 keyEvent->keyCode_ = KeyEvent::KEYCODE_VOLUME_UP; 2218 ASSERT_NO_FATAL_FAILURE(handler.NotifySubscriber(keyEvent, subscriber)); 2219 } 2220 2221 /** 2222 * @tc.name: KeySubscriberHandlerTest_OnSubscribeKeyEvent_004 2223 * @tc.desc: Test the funcation OnSubscribeKeyEvent 2224 * @tc.type: FUNC 2225 * @tc.require: 2226 */ 2227 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_OnSubscribeKeyEvent_004, TestSize.Level1) 2228 { 2229 CALL_DEBUG_ENTER; 2230 KeySubscriberHandler handler; 2231 KeyEvent::KeyItem item; 2232 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 2233 ASSERT_NE(keyEvent, nullptr); 2234 handler.enableCombineKey_ = false; 2235 keyEvent->SetKeyCode(KeyEvent::KEY_ACTION_UP); 2236 item.SetKeyCode(KeyEvent::KEYCODE_O); 2237 keyEvent->AddKeyItem(item); 2238 item.SetKeyCode(KeyEvent::KEYCODE_P); 2239 keyEvent->AddKeyItem(item); 2240 ASSERT_FALSE(handler.OnSubscribeKeyEvent(keyEvent)); 2241 handler.enableCombineKey_ = true; 2242 handler.hasEventExecuting_ = true; 2243 handler.keyEvent_ = KeyEvent::Create(); 2244 ASSERT_NE(handler.keyEvent_, nullptr); 2245 handler.keyEvent_->SetKeyCode(KeyEvent::KEY_ACTION_UP); 2246 handler.keyEvent_->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 2247 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 2248 item.SetKeyCode(KeyEvent::KEYCODE_O); 2249 handler.keyEvent_->AddKeyItem(item); 2250 item.SetKeyCode(KeyEvent::KEYCODE_P); 2251 handler.keyEvent_->AddKeyItem(item); 2252 ASSERT_TRUE(handler.OnSubscribeKeyEvent(keyEvent)); 2253 handler.hasEventExecuting_ = false; 2254 handler.needSkipPowerKeyUp_ = true; 2255 keyEvent->SetKeyCode(KeyEvent::KEY_ACTION_CANCEL); 2256 ASSERT_FALSE(handler.OnSubscribeKeyEvent(keyEvent)); 2257 } 2258 2259 /** 2260 * @tc.name: KeySubscriberHandlerTest_NotifySubscriber_003 2261 * @tc.desc: Test the funcation NotifySubscriber 2262 * @tc.type: FUNC 2263 * @tc.require: 2264 */ 2265 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifySubscriber_003, TestSize.Level1) 2266 { 2267 CALL_TEST_DEBUG; 2268 KeySubscriberHandler handler; 2269 SessionPtr sess; 2270 std::shared_ptr<KeyOption> keyOption; 2271 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 2272 ASSERT_NE(keyEvent, nullptr); 2273 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 2274 KeyEvent::KeyItem item; 2275 item.SetKeyCode(KeyEvent::KEYCODE_POWER); 2276 keyEvent->AddKeyItem(item); 2277 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 2278 ASSERT_NO_FATAL_FAILURE(handler.NotifySubscriber(keyEvent, subscriber)); 2279 item.SetKeyCode(KeyEvent::KEYCODE_CAMERA); 2280 keyEvent->AddKeyItem(item); 2281 keyEvent->SetKeyCode(KeyEvent::KEYCODE_CAMERA); 2282 ASSERT_NO_FATAL_FAILURE(handler.NotifySubscriber(keyEvent, subscriber)); 2283 } 2284 2285 /** 2286 * @tc.name: KeySubscriberHandlerTest_NotifySubscriber_004 2287 * @tc.desc: Test NotifySubscriber 2288 * @tc.type: FUNC 2289 * @tc.require: 2290 */ 2291 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifySubscriber_004, TestSize.Level1) 2292 { 2293 CALL_TEST_DEBUG; 2294 KeySubscriberHandler handler; 2295 SessionPtr sess; 2296 std::shared_ptr<KeyOption> keyOption; 2297 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 2298 ASSERT_NE(keyEvent, nullptr); 2299 2300 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 2301 ASSERT_NE(subscriber, nullptr); 2302 2303 keyEvent->keyCode_ = KeyEvent::KEYCODE_POWER; 2304 ASSERT_NO_FATAL_FAILURE(handler.NotifySubscriber(keyEvent, subscriber)); 2305 } 2306 2307 /** 2308 * @tc.name: KeySubscriberHandlerTest_NotifySubscriber_005 2309 * @tc.desc: Test NotifySubscriber 2310 * @tc.type: FUNC 2311 * @tc.require: 2312 */ 2313 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifySubscriber_005, TestSize.Level1) 2314 { 2315 CALL_TEST_DEBUG; 2316 KeySubscriberHandler handler; 2317 SessionPtr sess; 2318 std::shared_ptr<KeyOption> keyOption; 2319 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 2320 ASSERT_NE(keyEvent, nullptr); 2321 2322 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 2323 ASSERT_NE(subscriber, nullptr); 2324 keyEvent->keyCode_ = KeyEvent::KEYCODE_CAMERA; 2325 EXPECT_FALSE(EventLogHelper::IsBetaVersion()); 2326 EXPECT_FALSE(keyEvent->HasFlag(InputEvent::EVENT_FLAG_PRIVACY_MODE)); 2327 2328 NetPacket pkt(MmiMessageId::ON_SUBSCRIBE_KEY); 2329 EXPECT_FALSE(pkt.ChkRWError()); 2330 ASSERT_NO_FATAL_FAILURE(handler.NotifySubscriber(keyEvent, subscriber)); 2331 } 2332 2333 /** 2334 * @tc.name: KeySubscriberHandlerTest_HandleKeyDown_003 2335 * @tc.desc: Test the funcation HandleKeyDown 2336 * @tc.type: FUNC 2337 * @tc.require: 2338 */ 2339 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleKeyDown_003, TestSize.Level1) 2340 { 2341 CALL_DEBUG_ENTER; 2342 KeySubscriberHandler handler; 2343 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 2344 ASSERT_NE(keyEvent, nullptr); 2345 auto keyOption = std::make_shared<KeyOption>(); 2346 keyOption->isFinalKeyDown_ = true; 2347 keyEvent->keyCode_ = 1; 2348 SessionPtr sess; 2349 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 2350 std::list<std::shared_ptr<OHOS::MMI::KeySubscriberHandler::Subscriber>> subscribers; 2351 subscribers.push_back(subscriber); 2352 handler.subscriberMap_.insert(std::make_pair(keyOption, subscribers)); 2353 keyOption->finalKey_ = 5; 2354 bool ret = handler.HandleKeyDown(keyEvent); 2355 ASSERT_FALSE(ret); 2356 keyOption->finalKey_ = 1; 2357 subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 2358 subscribers.push_back(subscriber); 2359 handler.subscriberMap_.insert(std::make_pair(keyOption, subscribers)); 2360 KeyEvent::KeyItem item; 2361 item.SetKeyCode(KeyEvent::KEYCODE_CAMERA); 2362 keyEvent->AddKeyItem(item); 2363 keyEvent->SetKeyCode(KeyEvent::KEYCODE_CAMERA); 2364 ret = handler.HandleKeyDown(keyEvent); 2365 ASSERT_FALSE(ret); 2366 } 2367 2368 /** 2369 * @tc.name: KeySubscriberHandlerTest_SubscriberNotifyNap_002 2370 * @tc.desc: Test the funcation SubscriberNotifyNap 2371 * @tc.type: FUNC 2372 * @tc.require: 2373 */ 2374 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_SubscriberNotifyNap_002, TestSize.Level1) 2375 { 2376 CALL_TEST_DEBUG; 2377 KeySubscriberHandler handler; 2378 SessionPtr sess; 2379 std::shared_ptr<KeyOption> keyOption; 2380 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 2381 NapProcess napProcess; 2382 napProcess.instance_->napClientPid_ = REMOVE_OBSERVER; 2383 ASSERT_NO_FATAL_FAILURE(handler.SubscriberNotifyNap(subscriber)); 2384 napProcess.instance_->napClientPid_ = UNOBSERVED; 2385 ASSERT_NO_FATAL_FAILURE(handler.SubscriberNotifyNap(subscriber)); 2386 napProcess.instance_->napClientPid_ = 10; 2387 ASSERT_NO_FATAL_FAILURE(handler.SubscriberNotifyNap(subscriber)); 2388 } 2389 2390 /** 2391 * @tc.name: KeySubscriberHandlerTest_SubscriberNotifyNap_003 2392 * @tc.desc: Test the funcation SubscriberNotifyNap 2393 * @tc.type: FUNC 2394 * @tc.require: 2395 */ 2396 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_SubscriberNotifyNap_003, TestSize.Level1) 2397 { 2398 CALL_TEST_DEBUG; 2399 KeySubscriberHandler handler; 2400 SessionPtr sess; 2401 std::shared_ptr<KeyOption> keyOption; 2402 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 2403 ASSERT_NE(subscriber, nullptr); 2404 2405 NapProcess napProcess; 2406 napProcess.instance_->napClientPid_ = ACTIVE_EVENT; 2407 OHOS::MMI::NapProcess::NapStatusData napData; 2408 napData.pid = 2; 2409 napData.uid = 3; 2410 napData.bundleName = "programName"; 2411 EXPECT_FALSE(napProcess.IsNeedNotify(napData)); 2412 ASSERT_NO_FATAL_FAILURE(handler.SubscriberNotifyNap(subscriber)); 2413 } 2414 2415 /** 2416 * @tc.name: KeySubscriberHandlerTest_SubscribeKeyEvent_003 2417 * @tc.desc: Test subscribe keyEvent 2418 * @tc.type: FUNC 2419 * @tc.require: 2420 */ 2421 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_SubscribeKeyEvent_003, TestSize.Level1) 2422 { 2423 CALL_TEST_DEBUG; 2424 KeySubscriberHandler handler; 2425 int32_t subscribeId = 1; 2426 SessionPtr sess = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 2427 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 2428 std::set<int32_t> preKeys = { 2017, 2018, 2019, 2072, 2046 }; 2429 keyOption->SetPreKeys(preKeys); 2430 EXPECT_EQ(handler.SubscribeKeyEvent(sess, subscribeId, keyOption), RET_ERR); 2431 } 2432 2433 /** 2434 * @tc.name: KeySubscriberHandlerTest_SubscribeKeyEvent_004 2435 * @tc.desc: Test subscribe keyEvent 2436 * @tc.type: FUNC 2437 * @tc.require: 2438 */ 2439 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_SubscribeKeyEvent_004, TestSize.Level1) 2440 { 2441 CALL_TEST_DEBUG; 2442 KeySubscriberHandler handler; 2443 int32_t subscribeId = 1; 2444 SessionPtr sess = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 2445 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 2446 keyOption->SetFinalKey(2072); 2447 keyOption->SetFinalKeyDown(true); 2448 keyOption->SetFinalKeyDownDuration(100); 2449 EXPECT_NE(handler.SubscribeKeyEvent(sess, subscribeId, keyOption), RET_OK); 2450 } 2451 2452 /** 2453 * @tc.name: KeySubscriberHandlerTest_RemoveKeyGestureSubscriber 2454 * @tc.desc: Test RemoveKeyGestureSubscriber 2455 * @tc.type: FUNC 2456 * @tc.require: 2457 */ 2458 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_RemoveKeyGestureSubscriber, TestSize.Level1) 2459 { 2460 CALL_TEST_DEBUG; 2461 KeySubscriberHandler handler; 2462 int32_t subscribeId = 1; 2463 SessionPtr sess = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 2464 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 2465 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 2466 std::make_shared<KeySubscriberHandler::Subscriber>(subscribeId, sess, keyOption); 2467 std::list<std::shared_ptr<KeySubscriberHandler::Subscriber>> listSub; 2468 listSub.push_back(subscriber); 2469 subscribeId = 2; 2470 handler.keyGestures_.insert(std::make_pair(keyOption, listSub)); 2471 EXPECT_EQ(handler.RemoveKeyGestureSubscriber(sess, subscribeId), RET_ERR); 2472 } 2473 2474 /** 2475 * @tc.name: KeySubscriberHandlerTest_RemoveKeyGestureSubscriber_001 2476 * @tc.desc: Test RemoveKeyGestureSubscriber 2477 * @tc.type: FUNC 2478 * @tc.require: 2479 */ 2480 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_RemoveKeyGestureSubscriber_001, TestSize.Level1) 2481 { 2482 CALL_TEST_DEBUG; 2483 KeySubscriberHandler handler; 2484 int32_t subscribeId = 1; 2485 SessionPtr sess = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 2486 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 2487 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 2488 std::make_shared<KeySubscriberHandler::Subscriber>(subscribeId, sess, keyOption); 2489 std::list<std::shared_ptr<KeySubscriberHandler::Subscriber>> listSub; 2490 listSub.push_back(subscriber); 2491 SessionPtr session = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 2492 handler.keyGestures_.insert(std::make_pair(keyOption, listSub)); 2493 EXPECT_EQ(handler.RemoveKeyGestureSubscriber(session, subscribeId), RET_ERR); 2494 } 2495 2496 /** 2497 * @tc.name: KeySubscriberHandlerTest_RemoveKeyGestureSubscriber_002 2498 * @tc.desc: Test RemoveKeyGestureSubscriber 2499 * @tc.type: FUNC 2500 * @tc.require: 2501 */ 2502 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_RemoveKeyGestureSubscriber_002, TestSize.Level1) 2503 { 2504 CALL_TEST_DEBUG; 2505 KeySubscriberHandler handler; 2506 int32_t subscribeId = 1; 2507 SessionPtr sess = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 2508 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 2509 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 2510 std::make_shared<KeySubscriberHandler::Subscriber>(subscribeId, sess, keyOption); 2511 std::list<std::shared_ptr<KeySubscriberHandler::Subscriber>> listSub; 2512 listSub.push_back(subscriber); 2513 handler.keyGestures_.insert(std::make_pair(keyOption, listSub)); 2514 EXPECT_EQ(handler.RemoveKeyGestureSubscriber(sess, subscribeId), RET_OK); 2515 } 2516 2517 /** 2518 * @tc.name: KeySubscriberHandlerTest_OnSessionDelete_002 2519 * @tc.desc: Test OnSessionDelete 2520 * @tc.type: FUNC 2521 * @tc.require: 2522 */ 2523 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_OnSessionDelete_002, TestSize.Level1) 2524 { 2525 CALL_TEST_DEBUG; 2526 KeySubscriberHandler handler; 2527 int32_t subscribeId = 1; 2528 SessionPtr sess = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 2529 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 2530 2531 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 2532 std::make_shared<KeySubscriberHandler::Subscriber>(subscribeId, sess, keyOption); 2533 std::list<std::shared_ptr<KeySubscriberHandler::Subscriber>> listSub; 2534 listSub.push_back(subscriber); 2535 2536 SessionPtr session = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 2537 std::shared_ptr<KeySubscriberHandler::Subscriber> keySubscriber = 2538 std::make_shared<KeySubscriberHandler::Subscriber>(subscribeId, session, keyOption); 2539 listSub.push_back(keySubscriber); 2540 handler.keyGestures_.insert(std::make_pair(keyOption, listSub)); 2541 EXPECT_NO_FATAL_FAILURE(handler.OnSessionDelete(session)); 2542 } 2543 2544 /** 2545 * @tc.name: KeySubscriberHandlerTest_OnSessionDelete_003 2546 * @tc.desc: Test OnSessionDelete 2547 * @tc.type: FUNC 2548 * @tc.require: 2549 */ 2550 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_OnSessionDelete_003, TestSize.Level1) 2551 { 2552 CALL_TEST_DEBUG; 2553 KeySubscriberHandler handler; 2554 int32_t subscribeId = 1; 2555 SessionPtr sess = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 2556 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 2557 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 2558 std::make_shared<KeySubscriberHandler::Subscriber>(subscribeId, sess, keyOption); 2559 std::list<std::shared_ptr<KeySubscriberHandler::Subscriber>> listSub; 2560 handler.keyGestures_.insert(std::make_pair(keyOption, listSub)); 2561 EXPECT_NO_FATAL_FAILURE(handler.OnSessionDelete(sess)); 2562 } 2563 2564 /** 2565 * @tc.name: KeySubscriberHandlerTest_HandleKeyUpWithDelay_03 2566 * @tc.desc: Test HandleKeyUpWithDelay 2567 * @tc.type: FUNC 2568 * @tc.require: 2569 */ 2570 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleKeyUpWithDelay_03, TestSize.Level1) 2571 { 2572 CALL_TEST_DEBUG; 2573 KeySubscriberHandler handler; 2574 int32_t subscribeId = 1; 2575 SessionPtr sess = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 2576 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 2577 keyOption->SetFinalKeyUpDelay(-1); 2578 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 2579 std::make_shared<KeySubscriberHandler::Subscriber>(subscribeId, sess, keyOption); 2580 std::shared_ptr<KeyEvent> keyEvent = nullptr; 2581 EXPECT_NO_FATAL_FAILURE(handler.HandleKeyUpWithDelay(keyEvent, subscriber)); 2582 } 2583 2584 /** 2585 * @tc.name: KeySubscriberHandlerTest_HandleKeyUpWithDelay_04 2586 * @tc.desc: Test HandleKeyUpWithDelay 2587 * @tc.type: FUNC 2588 * @tc.require: 2589 */ 2590 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleKeyUpWithDelay_04, TestSize.Level1) 2591 { 2592 CALL_TEST_DEBUG; 2593 KeySubscriberHandler handler; 2594 int32_t subscribeId = 1; 2595 SessionPtr sess = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 2596 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 2597 keyOption->SetFinalKeyUpDelay(100); 2598 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 2599 std::make_shared<KeySubscriberHandler::Subscriber>(subscribeId, sess, keyOption); 2600 std::shared_ptr<KeyEvent> keyEvent = nullptr; 2601 EXPECT_NO_FATAL_FAILURE(handler.HandleKeyUpWithDelay(keyEvent, subscriber)); 2602 } 2603 2604 /** 2605 * @tc.name: KeySubscriberHandlerTest_DumpSubscriber 2606 * @tc.desc: Test DumpSubscriber 2607 * @tc.type: FUNC 2608 * @tc.require: 2609 */ 2610 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_DumpSubscriber, TestSize.Level1) 2611 { 2612 CALL_TEST_DEBUG; 2613 KeySubscriberHandler handler; 2614 int32_t subscribeId = 1; 2615 SessionPtr sess = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 2616 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 2617 keyOption->SetFinalKeyUpDelay(100); 2618 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 2619 std::make_shared<KeySubscriberHandler::Subscriber>(subscribeId, sess, keyOption); 2620 int32_t fd = 100; 2621 EXPECT_NO_FATAL_FAILURE(handler.DumpSubscriber(fd, subscriber)); 2622 2623 std::shared_ptr<KeyOption> option = std::make_shared<KeyOption>(); 2624 std::set<int32_t> preKeys = { 2020, 2021 }; 2625 option->SetPreKeys(preKeys); 2626 subscriber = std::make_shared<KeySubscriberHandler::Subscriber>(subscribeId, sess, option); 2627 EXPECT_NO_FATAL_FAILURE(handler.DumpSubscriber(fd, subscriber)); 2628 } 2629 2630 /** 2631 * @tc.name: KeySubscriberHandlerTest_InitDataShareListener 2632 * @tc.desc: Test InitDataShareListener 2633 * @tc.type: FUNC 2634 * @tc.require: 2635 */ 2636 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_InitDataShareListener, TestSize.Level1) 2637 { 2638 CALL_TEST_DEBUG; 2639 KeySubscriberHandler handler; 2640 EXPECT_NO_FATAL_FAILURE(handler.InitDataShareListener()); 2641 } 2642 2643 /** 2644 * @tc.name: KeySubscriberHandlerTest_RejectCallProcess 2645 * @tc.desc: Test RejectCallProcess 2646 * @tc.type: FUNC 2647 * @tc.require: 2648 */ 2649 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_RejectCallProcess, TestSize.Level1) 2650 { 2651 CALL_TEST_DEBUG; 2652 KeySubscriberHandler handler; 2653 EXPECT_NO_FATAL_FAILURE(handler.RejectCallProcess()); 2654 } 2655 2656 /** 2657 * @tc.name: KeySubscriberHandlerTest_HangUpCallProcess 2658 * @tc.desc: Test HangUpCallProcess 2659 * @tc.type: FUNC 2660 * @tc.require: 2661 */ 2662 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HangUpCallProcess, TestSize.Level1) 2663 { 2664 CALL_TEST_DEBUG; 2665 KeySubscriberHandler handler; 2666 EXPECT_NO_FATAL_FAILURE(handler.HangUpCallProcess()); 2667 } 2668 2669 /** 2670 * @tc.name: KeySubscriberHandlerTest_HandleCallEnded 2671 * @tc.desc: Test HandleCallEnded 2672 * @tc.type: FUNC 2673 * @tc.require: 2674 */ 2675 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleCallEnded, TestSize.Level1) 2676 { 2677 CALL_TEST_DEBUG; 2678 KeySubscriberHandler handler; 2679 auto keyEvent = KeyEvent::Create(); 2680 bool ret = false; 2681 handler.callBahaviorState_ = false; 2682 ret = handler.HandleCallEnded(keyEvent); 2683 ASSERT_FALSE(ret); 2684 handler.callBahaviorState_ = true; 2685 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_CANCEL); 2686 keyEvent->SetKeyCode(KeyEvent::KEYCODE_CAMERA); 2687 ret = handler.HandleCallEnded(keyEvent); 2688 ASSERT_FALSE(ret); 2689 2690 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 2691 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 2692 ret = handler.HandleCallEnded(keyEvent); 2693 ASSERT_FALSE(ret); 2694 2695 DISPLAY_MONITOR->SetScreenStatus(EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_ON); 2696 DEVICE_MONITOR->callState_ = StateType::CALL_STATUS_DIALING; 2697 ret = handler.HandleCallEnded(keyEvent); 2698 ASSERT_FALSE(ret); 2699 2700 DEVICE_MONITOR->callState_ = CALL_STATUS_INCOMING; 2701 ret = handler.HandleCallEnded(keyEvent); 2702 ASSERT_FALSE(ret); 2703 2704 DEVICE_MONITOR->callState_ = 10; 2705 ret = handler.HandleCallEnded(keyEvent); 2706 ASSERT_FALSE(ret); 2707 } 2708 2709 /** 2710 * @tc.name: KeySubscriberHandlerTest_RemoveSubscriberTimer 2711 * @tc.desc: Test RemoveSubscriberTimer 2712 * @tc.type: FUNC 2713 * @tc.require: 2714 */ 2715 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_RemoveSubscriberTimer, TestSize.Level1) 2716 { 2717 CALL_TEST_DEBUG; 2718 KeySubscriberHandler handler; 2719 auto keyEvent = KeyEvent::Create(); 2720 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 2721 for (auto i = 0; i < 5; i++) { 2722 KeyEvent::KeyItem keyItem; 2723 keyItem.SetKeyCode(KeyEvent::KEYCODE_POWER); 2724 keyItem.SetPressed(true); 2725 keyEvent->keys_.push_back(keyItem); 2726 } 2727 EXPECT_NO_FATAL_FAILURE(handler.RemoveSubscriberTimer(keyEvent)); 2728 } 2729 2730 /** 2731 * @tc.name: KeySubscriberHandlerTest_RemoveSubscriberKeyUpTimer 2732 * @tc.desc: Test RemoveSubscriberKeyUpTimer 2733 * @tc.type: FUNC 2734 * @tc.require: 2735 */ 2736 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_RemoveSubscriberKeyUpTimer, TestSize.Level1) 2737 { 2738 CALL_TEST_DEBUG; 2739 KeySubscriberHandler handler; 2740 auto keyEvent = KeyEvent::Create(); 2741 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 2742 EXPECT_NO_FATAL_FAILURE(handler.RemoveSubscriberKeyUpTimer(KeyEvent::KEYCODE_POWER)); 2743 } 2744 } // namespace MMI 2745 } // namespace OHOS 2746