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 
40 namespace OHOS {
41 namespace MMI {
42 namespace {
43 using namespace testing::ext;
44 const std::string PROGRAM_NAME = "uds_session_test";
45 constexpr int32_t MODULE_TYPE = 1;
46 constexpr int32_t UDS_FD = 1;
47 constexpr int32_t UDS_UID = 100;
48 constexpr int32_t UDS_PID = 100;
49 constexpr int32_t REMOVE_OBSERVER { -2 };
50 constexpr int32_t UNOBSERVED { -1 };
51 constexpr int32_t ACTIVE_EVENT { 2 };
52 } // namespace
53 
54 class KeySubscriberHandlerTest : public testing::Test {
55 public:
SetUpTestCase(void)56     static void SetUpTestCase(void) {}
TearDownTestCase(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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleCallEnded_001, TestSize.Level1)66 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleCallEnded_002, TestSize.Level1)101 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleCallEnded_003, TestSize.Level1)117 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HangUpCallProcess_001, TestSize.Level1)135 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HangUpCallProcess_002, TestSize.Level1)149 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_RejectCallProcess_001, TestSize.Level1)165 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_RejectCallProcess_002, TestSize.Level1)179 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleKeyEvent_001, TestSize.Level1)195 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_DumpSubscriber_001, TestSize.Level1)234 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, InputWindowsManagerTest_UnsubscribeKeyEvent_001, TestSize.Level1)254 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsEnableCombineKey_001, TestSize.Level1)282 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsEnableCombineKey_002, TestSize.Level1)303 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_EnableCombineKey_001, TestSize.Level1)326 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_SubscribeKeyEvent_001, TestSize.Level1)339 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_RemoveSubscriber_001, TestSize.Level1)359 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsEqualKeyOption_001, TestSize.Level1)376 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsPreKeysMatch_001, TestSize.Level1)416 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsEqualPreKeys_001, TestSize.Level1)438 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsMatchForegroundPid_001, TestSize.Level1)457 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifyKeyDownSubscriber_001, TestSize.Level1)472 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifyKeyDownRightNow_001, TestSize.Level1)491 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifyKeyDownDelay_001, TestSize.Level1)508 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_InitSessionDeleteCallback_001, TestSize.Level1)530 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleKeyDown_001, TestSize.Level1)546 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_RemoveKeyCode_001, TestSize.Level1)564 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_AddSubscriber_001, TestSize.Level1)584 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsFunctionKey_001, TestSize.Level1)606 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_CloneKeyEvent_001, TestSize.Level1)632 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifyKeyUpSubscriber_001, TestSize.Level1)649 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsEnableCombineKeySwipe_001, TestSize.Level1)674 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_OnSubscribeKeyEvent_001, TestSize.Level1)709 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_OnSessionDelete_001, TestSize.Level1)734 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_ClearSubscriberTimer_001, TestSize.Level1)760 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_OnTimer_001, TestSize.Level1)780 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_SubscriberNotifyNap_001, TestSize.Level1)798 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleKeyUp_001, TestSize.Level1)814 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifySubscriber_001, TestSize.Level1)834 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleKeyCancel_001, TestSize.Level1)856 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_PrintKeyOption_001, TestSize.Level1)879 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleKeyUpWithDelay_002, TestSize.Level1)897 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_001, TestSize.Level1)917 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_002, TestSize.Level1)939 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_003, TestSize.Level1)965 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_004, TestSize.Level1)991 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_005, TestSize.Level1)1017 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_006, TestSize.Level1)1039 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_007, TestSize.Level1)1065 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_008, TestSize.Level1)1087 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_009, TestSize.Level1)1103 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_SubscribeKeyEvent_002, TestSize.Level1)1119 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsEqualKeyOption, TestSize.Level1)1146 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsEnableCombineKey_003, TestSize.Level1)1186 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsEnableCombineKey_004, TestSize.Level1)1219 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsEnableCombineKey_005, TestSize.Level1)1239 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsEnableCombineKey_006, TestSize.Level1)1259 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_RemoveSubscriber, TestSize.Level1)1279 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsFunctionKey, TestSize.Level1)1303 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_OnSubscribeKeyEvent, TestSize.Level1)1333 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_OnSessionDelete, TestSize.Level1)1376 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsPreKeysMatch, TestSize.Level1)1399 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsMatchForegroundPid, TestSize.Level1)1421 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifyKeyDownSubscriber, TestSize.Level1)1446 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifyKeyDownRightNow, TestSize.Level1)1470 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifyKeyDownDelay, TestSize.Level1)1499 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifyKeyUpSubscriber, TestSize.Level1)1529 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsKeyEventSubscribed, TestSize.Level1)1559 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_RemoveKeyCode, TestSize.Level1)1589 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsRepeatedKeyEvent, TestSize.Level1)1605 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_010, TestSize.Level1)1642 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_OnSubscribeKeyEvent_002, TestSize.Level1)1678 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_OnSubscribeKeyEvent_003, TestSize.Level1)1704 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifySubscriber_002, TestSize.Level1)1725 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_AddTimer_001, TestSize.Level1)1747 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleKeyDown_002, TestSize.Level1)1776 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleKeyUp_002, TestSize.Level1)1819 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_01, TestSize.Level1)1869 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_02, TestSize.Level1)1898 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_03, TestSize.Level1)1919 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_04, TestSize.Level1)1943 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_05, TestSize.Level1)1966 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_06, TestSize.Level1)1989 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_07, TestSize.Level1)2012 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_08, TestSize.Level1)2035 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_09, TestSize.Level1)2055 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_10, TestSize.Level1)2077 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_11, TestSize.Level1)2100 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_AddKeyGestureSubscriber_01, TestSize.Level1)2123 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_AddKeyGestureSubscriber_02, TestSize.Level1)2141 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_AddKeyGestureSubscriber_03, TestSize.Level1)2177 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_RemoveKeyGestureSubscriber_01, TestSize.Level1)2213 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, InputWindowsManagerTest_UnsubscribeKeyEvent_01, TestSize.Level1)2253 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifySubscriber_01, TestSize.Level1)2272 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifySubscriber_02, TestSize.Level1)2293 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_OnSubscribeKeyEvent_004, TestSize.Level1)2314 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifySubscriber_003, TestSize.Level1)2352 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifySubscriber_004, TestSize.Level1)2378 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifySubscriber_005, TestSize.Level1)2400 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleKeyDown_003, TestSize.Level1)2426 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_SubscriberNotifyNap_002, TestSize.Level1)2461 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_SubscriberNotifyNap_003, TestSize.Level1)2483 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_SubscribeKeyEvent_003, TestSize.Level1)2508 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_SubscribeKeyEvent_004, TestSize.Level1)2526 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_AddKeyGestureSubscriber_003, TestSize.Level1)2545 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_RemoveKeyGestureSubscriber, TestSize.Level1)2564 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_RemoveKeyGestureSubscriber_001, TestSize.Level1)2586 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_RemoveKeyGestureSubscriber_002, TestSize.Level1)2608 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_OnSessionDelete_002, TestSize.Level1)2629 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_OnSessionDelete_003, TestSize.Level1)2656 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleKeyUpWithDelay_03, TestSize.Level1)2676 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleKeyUpWithDelay_04, TestSize.Level1)2696 HWTEST_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  */
HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_DumpSubscriber, TestSize.Level1)2716 HWTEST_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