1 /*
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include "power_key_option_test.h"
16 #ifdef HAS_MULTIMODALINPUT_INPUT_PART
17 #include <input_manager.h>
18 #endif
19 #include "power_mgr_service.h"
20
21 using namespace testing::ext;
22 using namespace OHOS::MMI;
23 using namespace OHOS::PowerMgr;
24 using namespace OHOS;
25 using namespace std;
26 static sptr<PowerMgrService> g_service;
27 static constexpr int SLEEP_WAIT_TIME_S = 2;
28
SetUpTestCase(void)29 void PowerKeyOptionTest::SetUpTestCase(void)
30 {
31 g_service = DelayedSpSingleton<PowerMgrService>::GetInstance();
32 g_service->OnStart();
33 }
34
TearDownTestCase(void)35 void PowerKeyOptionTest::TearDownTestCase(void)
36 {
37 g_service->OnStop();
38 DelayedSpSingleton<PowerMgrService>::DestroyInstance();
39 }
40
41 #ifdef HAS_MULTIMODALINPUT_INPUT_PART
42 std::function<void(std::shared_ptr<KeyEvent>)> callbackPowerWake_;
43 std::function<void(std::shared_ptr<KeyEvent>)> callbackPowerSuspend_;
44 std::function<void(std::shared_ptr<KeyEvent>)> callbackTp_;
45
SubscribeKeyEvent(std::shared_ptr<KeyOption> keyOption,std::function<void (std::shared_ptr<KeyEvent>)> callback)46 int32_t MMI::InputManager::SubscribeKeyEvent(std::shared_ptr<KeyOption> keyOption,
47 std::function<void(std::shared_ptr<KeyEvent>)> callback)
48 {
49 POWER_HILOGI(LABEL_TEST, "PowerKeyOptionTest SubscribeKeyEvent");
50 if (keyOption->GetFinalKey() == MMI::KeyEvent::KEYCODE_POWER) {
51 if (keyOption->IsFinalKeyDown()) {
52 callbackPowerWake_ = callback;
53 } else {
54 callbackPowerSuspend_ = callback;
55 }
56 } else if (keyOption->GetFinalKey() == MMI::KeyEvent::KEYCODE_SLEEP) {
57 callbackTp_ = callback;
58 }
59 return 0;
60 }
61 #endif
62
63 namespace {
64 /**
65 * @tc.name: PowerKeyOptionTest001
66 * @tc.desc: test simulate powerkey event when screenoff
67 * @tc.type: FUNC
68 */
69 #ifdef HAS_MULTIMODALINPUT_INPUT_PART
70 HWTEST_F(PowerKeyOptionTest, PowerKeyOptionTest001, TestSize.Level0)
71 {
72 POWER_HILOGI(LABEL_TEST, "PowerKeyOptionTest001 function start!");
73 GTEST_LOG_(INFO) << "PowerKeyOptionTest001: start";
74 g_service->WakeupControllerInit();
75 g_service->SuspendControllerInit();
76 g_service->SuspendDevice(
77 static_cast<int64_t>(time(nullptr)), SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION, false);
78 EXPECT_FALSE(g_service->IsScreenOn());
79
80 std::shared_ptr<MMI::KeyEvent> keyEventPowerkeyDown = MMI::KeyEvent::Create();
81 keyEventPowerkeyDown->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
82 keyEventPowerkeyDown->SetKeyCode(MMI::KeyEvent::KEYCODE_POWER);
83 std::shared_ptr<MMI::KeyEvent> keyEventPowerkeyUp = MMI::KeyEvent::Create();
84 keyEventPowerkeyUp->SetKeyAction(MMI::KeyEvent::KEY_ACTION_UP);
85 keyEventPowerkeyUp->SetKeyCode(MMI::KeyEvent::KEYCODE_POWER);
86
87 EXPECT_NE(callbackPowerWake_, nullptr);
88 callbackPowerWake_(keyEventPowerkeyDown);
89 callbackPowerWake_(keyEventPowerkeyUp);
90 callbackPowerWake_(keyEventPowerkeyDown);
91 callbackPowerWake_(keyEventPowerkeyUp);
92 EXPECT_TRUE(g_service->IsScreenOn());
93
94 std::shared_ptr<WakeupController> wakeupController = g_service->GetWakeupController();
95 std::shared_ptr<SuspendController> suspendController = g_service->GetSuspendController();
96 EXPECT_NE(wakeupController, nullptr);
97 EXPECT_NE(suspendController, nullptr);
98 wakeupController->monitorMap_.clear();
99 suspendController->monitorMap_.clear();
100 callbackPowerWake_(keyEventPowerkeyDown);
101 callbackPowerWake_(keyEventPowerkeyUp);
102 callbackPowerWake_(keyEventPowerkeyDown);
103 callbackPowerWake_(keyEventPowerkeyUp);
104 GTEST_LOG_(INFO) << "PowerKeyOptionTest001: end";
105 POWER_HILOGI(LABEL_TEST, "PowerKeyOptionTest001 function end!");
106 }
107 #endif
108
109 /**
110 * @tc.name: PowerKeyOptionTest002
111 * @tc.desc: test simulate powerkey event when screenon
112 * @tc.type: FUNC
113 */
114 #ifdef HAS_MULTIMODALINPUT_INPUT_PART
115 HWTEST_F(PowerKeyOptionTest, PowerKeyOptionTest002, TestSize.Level0)
116 {
117 POWER_HILOGI(LABEL_TEST, "PowerKeyOptionTest002 function start!");
118 GTEST_LOG_(INFO) << "PowerKeyOptionTest002: start";
119 g_service->WakeupControllerInit();
120 g_service->SuspendControllerInit();
121 g_service->WakeupDevice(
122 static_cast<int64_t>(time(nullptr)), WakeupDeviceType::WAKEUP_DEVICE_PLUG_CHANGE, "plug change");
123 EXPECT_TRUE(g_service->IsScreenOn());
124
125 std::shared_ptr<MMI::KeyEvent> keyEventPowerkeyDown = MMI::KeyEvent::Create();
126 keyEventPowerkeyDown->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
127 keyEventPowerkeyDown->SetKeyCode(MMI::KeyEvent::KEYCODE_POWER);
128 std::shared_ptr<MMI::KeyEvent> keyEventPowerkeyUp = MMI::KeyEvent::Create();
129 keyEventPowerkeyUp->SetKeyAction(MMI::KeyEvent::KEY_ACTION_UP);
130 keyEventPowerkeyUp->SetKeyCode(MMI::KeyEvent::KEYCODE_POWER);
131
132 EXPECT_NE(callbackPowerSuspend_, nullptr);
133 callbackPowerSuspend_(keyEventPowerkeyDown);
134 callbackPowerSuspend_(keyEventPowerkeyUp);
135 sleep(SLEEP_WAIT_TIME_S);
136 EXPECT_FALSE(g_service->IsScreenOn());
137
138 std::shared_ptr<WakeupController> wakeupController = g_service->GetWakeupController();
139 std::shared_ptr<SuspendController> suspendController = g_service->GetSuspendController();
140 EXPECT_NE(wakeupController, nullptr);
141 EXPECT_NE(suspendController, nullptr);
142 wakeupController->monitorMap_.clear();
143 suspendController->monitorMap_.clear();
144 callbackPowerSuspend_(keyEventPowerkeyDown);
145 callbackPowerSuspend_(keyEventPowerkeyUp);
146 GTEST_LOG_(INFO) << "PowerKeyOptionTest002: end";
147 POWER_HILOGI(LABEL_TEST, "PowerKeyOptionTest002 function end!");
148 }
149 #endif
150
151 /**
152 * @tc.name: PowerKeyOptionTest003
153 * @tc.desc: test simulate tpcover event when screenon
154 * @tc.type: FUNC
155 */
156 #ifdef HAS_MULTIMODALINPUT_INPUT_PART
157 HWTEST_F(PowerKeyOptionTest, PowerKeyOptionTest003, TestSize.Level0)
158 {
159 POWER_HILOGI(LABEL_TEST, "PowerKeyOptionTest003 function start!");
160 GTEST_LOG_(INFO) << "PowerKeyOptionTest003: start";
161 g_service->WakeupControllerInit();
162 g_service->SuspendControllerInit();
163 g_service->WakeupDevice(
164 static_cast<int64_t>(time(nullptr)), WakeupDeviceType::WAKEUP_DEVICE_PLUG_CHANGE, "plug change");
165 EXPECT_TRUE(g_service->IsScreenOn());
166
167 std::shared_ptr<MMI::KeyEvent> keyEventTPCover = MMI::KeyEvent::Create();
168 keyEventTPCover->SetKeyCode(MMI::KeyEvent::KEYCODE_SLEEP);
169
170 EXPECT_NE(callbackTp_, nullptr);
171 callbackTp_(keyEventTPCover);
172 sleep(SLEEP_WAIT_TIME_S);
173 EXPECT_FALSE(g_service->IsScreenOn());
174
175 std::shared_ptr<WakeupController> wakeupController = g_service->GetWakeupController();
176 std::shared_ptr<SuspendController> suspendController = g_service->GetSuspendController();
177 EXPECT_NE(wakeupController, nullptr);
178 EXPECT_NE(suspendController, nullptr);
179 wakeupController->monitorMap_.clear();
180 suspendController->monitorMap_.clear();
181 callbackTp_(keyEventTPCover);
182 GTEST_LOG_(INFO) << "PowerKeyOptionTest003: end";
183 POWER_HILOGI(LABEL_TEST, "PowerKeyOptionTest003 function end!");
184 }
185 #endif
186 } // namespace