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