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