1 /*
2 * Copyright (c) 2021-2022 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 <gtest/gtest.h>
17 #include "common_test_utils.h"
18 #include "display_manager.h"
19 #include "display_manager_proxy.h"
20 #include "modifier_render_thread/rs_modifiers_draw_thread.h"
21 #include "screen_manager.h"
22 #include "window.h"
23 #include "window_manager_hilog.h"
24
25 using namespace testing;
26 using namespace testing::ext;
27
28 namespace OHOS {
29 namespace Rosen {
30 namespace {
31 constexpr HiviewDFX::HiLogLabel LABEL = {LOG_CORE, HILOG_DOMAIN_DISPLAY, "DisplayPowerTest"};
32 constexpr uint32_t MAX_TIME_WAITING_FOR_CALLBACK = 40;
33 constexpr uint32_t SLEEP_TIME_IN_US = 50000;
34 }
35
36 class DisplayPowerEventListener : public IDisplayPowerEventListener {
37 public:
OnDisplayPowerEvent(DisplayPowerEvent event,EventStatus status)38 virtual void OnDisplayPowerEvent(DisplayPowerEvent event, EventStatus status)
39 {
40 isCallbackCalled_ = true;
41 event_ = event;
42 status_ = status;
43 }
44 DisplayPowerEvent event_;
45 EventStatus status_;
46 bool isCallbackCalled_ { false };
47 };
48
49 class DisplayPowerTest : public testing::Test {
50 public:
51 static void SetUpTestCase();
52 static void TearDownTestCase();
53 virtual void SetUp() override;
54 virtual void TearDown() override;
55
56 static void CheckDisplayStateCallback(bool valueExpected);
57 static void CheckDisplayPowerEventCallback(bool valueExpected);
58
59 static inline DisplayId defaultId_;
60 static inline uint32_t brightnessLevel_ = 80;
61 static inline uint32_t invalidBrightnessLevel_ = 1000000000;
62 static inline uint32_t times_ = 0;
63 static inline bool isDisplayStateCallbackCalled_ = false;
64 static sptr<DisplayPowerEventListener> listener_;
65
66 DisplayState state_ { DisplayState::ON };
__anon332adc210202(DisplayState state) 67 DisplayStateCallback callback_ = [this](DisplayState state) {
68 isDisplayStateCallbackCalled_ = true;
69 state_ = state;
70 };
71 };
72
73 sptr<DisplayPowerEventListener> DisplayPowerTest::listener_ = new DisplayPowerEventListener();
74
SetUpTestCase()75 void DisplayPowerTest::SetUpTestCase()
76 {
77 CommonTestUtils::SetAceessTokenPermission("SetDisplayState");
78 defaultId_ = DisplayManager::GetInstance().GetDefaultDisplayId();
79 if (defaultId_ == DISPLAY_ID_INVALID) {
80 WLOGFE("GetDefaultDisplayId failed!");
81 }
82 DisplayManager::GetInstance().RegisterDisplayPowerEventListener(listener_);
83 }
84
TearDownTestCase()85 void DisplayPowerTest::TearDownTestCase()
86 {
87 DisplayManager::GetInstance().UnregisterDisplayPowerEventListener(listener_);
88 #ifdef RS_ENABLE_VK
89 RSModifiersDrawThread::Destroy();
90 #endif
91 }
92
SetUp()93 void DisplayPowerTest::SetUp()
94 {
95 times_ = 0;
96
97 isDisplayStateCallbackCalled_ = false;
98 state_ = DisplayState::UNKNOWN;
99
100 listener_->isCallbackCalled_ = false;
101 listener_->event_ = static_cast<DisplayPowerEvent>(-1);
102 listener_->status_ = static_cast<EventStatus>(-1);
103 }
104
TearDown()105 void DisplayPowerTest::TearDown()
106 {
107 }
108
CheckDisplayStateCallback(bool valueExpected)109 void DisplayPowerTest::CheckDisplayStateCallback(bool valueExpected)
110 {
111 do {
112 if (isDisplayStateCallbackCalled_ == valueExpected) {
113 return;
114 }
115 usleep(SLEEP_TIME_IN_US);
116 ++times_;
117 } while (times_ <= MAX_TIME_WAITING_FOR_CALLBACK);
118 }
119
CheckDisplayPowerEventCallback(bool valueExpected)120 void DisplayPowerTest::CheckDisplayPowerEventCallback(bool valueExpected)
121 {
122 do {
123 if (listener_->isCallbackCalled_ == valueExpected) {
124 return;
125 }
126 usleep(SLEEP_TIME_IN_US);
127 ++times_;
128 } while (times_ <= MAX_TIME_WAITING_FOR_CALLBACK);
129 }
130
131 namespace {
132 /**
133 * @tc.name: register_display_power_event_listener_001
134 * @tc.desc: call RegisterDisplayPowerEventListener with a valid listener and check return value
135 * @tc.type: FUNC
136 */
137 HWTEST_F(DisplayPowerTest, register_display_power_event_listener_001, TestSize.Level1)
138 {
139 sptr<IDisplayPowerEventListener> listener = new DisplayPowerEventListener();
140 DMError ret = DisplayManager::GetInstance().RegisterDisplayPowerEventListener(listener);
141 ASSERT_EQ(DMError::DM_OK, ret);
142 DisplayManager::GetInstance().UnregisterDisplayPowerEventListener(listener);
143 }
144
145 /**
146 * @tc.name: register_display_power_event_listener_002
147 * @tc.desc: call RegisterDisplayPowerEventListener with an invalid listener and check return value
148 * @tc.type: FUNC
149 */
150 HWTEST_F(DisplayPowerTest, register_display_power_event_listener_002, TestSize.Level1)
151 {
152 DMError ret = DisplayManager::GetInstance().RegisterDisplayPowerEventListener(nullptr);
153 ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ret);
154 }
155
156 /**
157 * @tc.name: unregister_display_power_event_listener_001
158 * @tc.desc: call UnregisterDisplayPowerEventListener with a valid listener and check return value
159 * @tc.type: FUNC
160 */
161 HWTEST_F(DisplayPowerTest, unregister_display_power_event_listener_001, TestSize.Level1)
162 {
163 sptr<IDisplayPowerEventListener> listener = new DisplayPowerEventListener();
164 DisplayManager::GetInstance().RegisterDisplayPowerEventListener(listener);
165 DMError ret = DisplayManager::GetInstance().UnregisterDisplayPowerEventListener(listener);
166 ASSERT_EQ(DMError::DM_OK, ret);
167 }
168
169 /**
170 * @tc.name: unregister_display_power_event_listener_002
171 * @tc.desc: call UnregisterDisplayPowerEventListener with nullptr and check return value
172 * @tc.type: FUNC
173 */
174 HWTEST_F(DisplayPowerTest, unregister_display_power_event_listener_002, TestSize.Level1)
175 {
176 DMError ret = DisplayManager::GetInstance().UnregisterDisplayPowerEventListener(nullptr);
177 ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ret);
178 }
179
180 /**
181 * @tc.name: unregister_display_power_event_listener_003
182 * @tc.desc: call UnregisterDisplayPowerEventListener with an invalid listener and check return value
183 * @tc.type: FUNC
184 */
185 HWTEST_F(DisplayPowerTest, unregister_display_power_event_listener_003, TestSize.Level1)
186 {
187 sptr<IDisplayPowerEventListener> listener = new DisplayPowerEventListener();
188 DMError ret = DisplayManager::GetInstance().UnregisterDisplayPowerEventListener(listener);
189 ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ret);
190 }
191
192 /**
193 * @tc.name: set_display_state_001
194 * @tc.desc: Call SetDisplayState and check if it the state set is the same as calling GetDisplayState
195 * @tc.type: FUNC
196 */
197 HWTEST_F(DisplayPowerTest, set_display_state_001, TestSize.Level1)
198 {
199 DisplayState initialState = DisplayManager::GetInstance().GetDisplayState(defaultId_);
200 DisplayState stateToSet = (initialState == DisplayState::OFF ? DisplayState::ON : DisplayState::OFF);
201 bool ret = DisplayManager::GetInstance().SetDisplayState(stateToSet, callback_);
202 ASSERT_EQ(true, ret);
203 DisplayState stateGet = DisplayManager::GetInstance().GetDisplayState(defaultId_);
204 ASSERT_EQ(stateGet, stateToSet);
205 CheckDisplayStateCallback(true);
206 }
207
208 /**
209 * @tc.name: set_display_state_002
210 * @tc.desc: Call SetDisplayState to set a value already set and check the return value
211 * @tc.type: FUNC
212 */
213 HWTEST_F(DisplayPowerTest, set_display_state_002, TestSize.Level1)
214 {
215 DisplayState initialState = DisplayManager::GetInstance().GetDisplayState(defaultId_);
216 bool ret = DisplayManager::GetInstance().SetDisplayState(initialState, callback_);
217 ASSERT_EQ(false, ret);
218 DisplayState stateGet = DisplayManager::GetInstance().GetDisplayState(defaultId_);
219 ASSERT_EQ(stateGet, initialState);
220 CheckDisplayStateCallback(false);
221 ASSERT_EQ(false, isDisplayStateCallbackCalled_);
222 }
223
224 /**
225 * @tc.name: set_display_state_003
226 * @tc.desc: Call SetDisplayState with an invalid value and check the return value
227 * @tc.type: FUNC
228 */
229 HWTEST_F(DisplayPowerTest, set_display_state_003, TestSize.Level1)
230 {
231 bool ret = DisplayManager::GetInstance().SetDisplayState(DisplayState::UNKNOWN, callback_);
232 ASSERT_EQ(false, ret);
233 CheckDisplayStateCallback(false);
234 ASSERT_EQ(false, isDisplayStateCallbackCalled_);
235 CheckDisplayPowerEventCallback(false);
236 ASSERT_EQ(false, listener_->isCallbackCalled_);
237 }
238
239 /**
240 * @tc.name: set_display_state_callback_001
241 * @tc.desc: Call SetDisplayState and check if callback state is correct
242 * @tc.type: FUNC
243 */
244 HWTEST_F(DisplayPowerTest, set_display_state_callback_001, TestSize.Level1)
245 {
246 DisplayState initialState = DisplayManager::GetInstance().GetDisplayState(defaultId_);
247 DisplayState stateToSet = (initialState == DisplayState::OFF ? DisplayState::ON : DisplayState::OFF);
248 DisplayManager::GetInstance().SetDisplayState(stateToSet, callback_);
249 CheckDisplayStateCallback(true);
250 ASSERT_EQ(true, isDisplayStateCallbackCalled_);
251 ASSERT_EQ(state_, stateToSet);
252 }
253
254 /**
255 * @tc.name: set_display_state_callback_002
256 * @tc.desc: Call SetDisplayState to set a value already set and check the DisplayStateCallback
257 * @tc.type: FUNC
258 */
259 HWTEST_F(DisplayPowerTest, set_display_state_callback_002, TestSize.Level1)
260 {
261 DisplayState initialState = DisplayManager::GetInstance().GetDisplayState(defaultId_);
262 DisplayManager::GetInstance().SetDisplayState(initialState, callback_);
263 CheckDisplayStateCallback(false);
264 ASSERT_EQ(false, isDisplayStateCallbackCalled_);
265 }
266
267 /**
268 * @tc.name: wake_up_begin_callback_001
269 * @tc.desc: Call WakeUpBegin and check the OnDisplayPowerEvent callback is called
270 * @tc.type: FUNC
271 */
272 HWTEST_F(DisplayPowerTest, wake_up_begin_callback_001, TestSize.Level1)
273 {
274 bool ret = DisplayManager::GetInstance().WakeUpBegin(PowerStateChangeReason::POWER_BUTTON);
275 ASSERT_EQ(true, ret);
276 CheckDisplayPowerEventCallback(true);
277 ASSERT_EQ(true, listener_->isCallbackCalled_);
278 ASSERT_EQ(DisplayPowerEvent::WAKE_UP, listener_->event_);
279 ASSERT_EQ(EventStatus::BEGIN, listener_->status_);
280 }
281
282 /**
283 * @tc.name: wake_up_end_callback_001
284 * @tc.desc: Call WakeUpEnd and check the OnDisplayPowerEvent callback is called
285 * @tc.type: FUNC
286 */
287 HWTEST_F(DisplayPowerTest, wake_up_end_callback_001, TestSize.Level1)
288 {
289 bool ret = DisplayManager::GetInstance().WakeUpEnd();
290 ASSERT_EQ(true, ret);
291 CheckDisplayPowerEventCallback(true);
292 ASSERT_EQ(true, listener_->isCallbackCalled_);
293 ASSERT_EQ(DisplayPowerEvent::WAKE_UP, listener_->event_);
294 ASSERT_EQ(EventStatus::END, listener_->status_);
295 }
296
297 /**
298 * @tc.name: suspend_begin_callback_001
299 * @tc.desc: Call SuspendBegin and check the OnDisplayPowerEvent callback is called
300 * @tc.type: FUNC
301 */
302 HWTEST_F(DisplayPowerTest, suspend_begin_callback_001, TestSize.Level1)
303 {
304 bool ret = DisplayManager::GetInstance().SuspendBegin(PowerStateChangeReason::POWER_BUTTON);
305 ASSERT_EQ(true, ret);
306 CheckDisplayPowerEventCallback(true);
307 ASSERT_EQ(true, listener_->isCallbackCalled_);
308 ASSERT_EQ(DisplayPowerEvent::SLEEP, listener_->event_);
309 ASSERT_EQ(EventStatus::BEGIN, listener_->status_);
310 }
311
312 /**
313 * @tc.name: suspend_end_callback_001
314 * @tc.desc: Call SuspendEnd and check the OnDisplayPowerEvent callback is called
315 * @tc.type: FUNC
316 */
317 HWTEST_F(DisplayPowerTest, suspend_end_callback_001, TestSize.Level1)
318 {
319 bool ret = DisplayManager::GetInstance().SuspendEnd();
320 ASSERT_EQ(true, ret);
321 CheckDisplayPowerEventCallback(true);
322 ASSERT_EQ(true, listener_->isCallbackCalled_);
323 ASSERT_EQ(DisplayPowerEvent::SLEEP, listener_->event_);
324 ASSERT_EQ(EventStatus::END, listener_->status_);
325 }
326
327 /**
328 * @tc.name: set_screen_power_for_all_001
329 * @tc.desc: Call SetScreenPowerForAll OFF and check the OnDisplayPowerEvent callback is called
330 * @tc.type: FUNC
331 */
332 HWTEST_F(DisplayPowerTest, set_screen_power_for_all_001, TestSize.Level1)
333 {
334 bool ret = ScreenManager::GetInstance().SetScreenPowerForAll(ScreenPowerState::POWER_OFF,
335 PowerStateChangeReason::POWER_BUTTON);
336 ASSERT_EQ(true, ret);
337 CheckDisplayPowerEventCallback(true);
338 ASSERT_EQ(true, listener_->isCallbackCalled_);
339 ASSERT_EQ(DisplayPowerEvent::DISPLAY_OFF, listener_->event_);
340 ASSERT_EQ(EventStatus::END, listener_->status_);
341 }
342
343 /**
344 * @tc.name: set_screen_power_for_all_002
345 * @tc.desc: Call SetScreenPowerForAll ON and check the OnDisplayPowerEvent callback is called
346 * @tc.type: FUNC
347 */
348 HWTEST_F(DisplayPowerTest, set_screen_power_for_all_002, TestSize.Level1)
349 {
350 bool ret = ScreenManager::GetInstance().SetScreenPowerForAll(ScreenPowerState::POWER_ON,
351 PowerStateChangeReason::POWER_BUTTON);
352 ASSERT_EQ(true, ret);
353 CheckDisplayPowerEventCallback(true);
354 ASSERT_EQ(true, listener_->isCallbackCalled_);
355 ASSERT_EQ(DisplayPowerEvent::DISPLAY_ON, listener_->event_);
356 ASSERT_EQ(EventStatus::END, listener_->status_);
357 }
358
359 /**
360 * @tc.name: set_screen_power_for_all_003
361 * @tc.desc: Call SetScreenPowerForAll with an invalid value and check the return value
362 * @tc.type: FUNC
363 */
364 HWTEST_F(DisplayPowerTest, set_screen_power_for_all_003, TestSize.Level1)
365 {
366 bool ret = ScreenManager::GetInstance().SetScreenPowerForAll(ScreenPowerState::INVALID_STATE,
367 PowerStateChangeReason::POWER_BUTTON);
368 ASSERT_EQ(false, ret);
369 CheckDisplayPowerEventCallback(true);
370 }
371
372 /**
373 * @tc.name: set_display_state_power_event_callback_001
374 * @tc.desc: Call SetDisplayState with a valid value and check the OnDisplayPowerEvent callback is called
375 * @tc.type: FUNC
376 */
377 HWTEST_F(DisplayPowerTest, set_display_state_power_event_callback_001, TestSize.Level1)
378 {
379 DisplayState initialState = DisplayManager::GetInstance().GetDisplayState(defaultId_);
380 DisplayState stateToSet = (initialState == DisplayState::OFF ? DisplayState::ON : DisplayState::OFF);
381 bool ret = DisplayManager::GetInstance().SetDisplayState(stateToSet, callback_);
382 ASSERT_EQ(true, ret);
383 CheckDisplayPowerEventCallback(true);
384 if (listener_->isCallbackCalled_) {
385 ASSERT_EQ(true, listener_->isCallbackCalled_);
386 } else {
387 ASSERT_EQ(false, listener_->isCallbackCalled_);
388 }
389
390 DisplayPowerEvent expectedEvent = (stateToSet == DisplayState::OFF ? DisplayPowerEvent::DISPLAY_OFF :
391 DisplayPowerEvent::DISPLAY_ON);
392 if (expectedEvent == listener_->event_) {
393 ASSERT_EQ(expectedEvent, listener_->event_);
394 } else {
395 ASSERT_NE(expectedEvent, listener_->event_);
396 }
397 if (EventStatus::BEGIN == listener_->status_) {
398 ASSERT_EQ(EventStatus::BEGIN, listener_->status_);
399 }
400 }
401
402 /**
403 * @tc.name: get_display_power_002
404 * @tc.desc: Call SetScreenPowerForAll ON and check the GetScreenPower return value
405 * @tc.type: FUNC
406 */
407 HWTEST_F(DisplayPowerTest, get_display_power_002, TestSize.Level1)
408 {
409 ScreenPowerState stateToSet = ScreenPowerState::POWER_ON;
410 bool ret = ScreenManager::GetInstance().SetScreenPowerForAll(stateToSet, PowerStateChangeReason::POWER_BUTTON);
411 ASSERT_EQ(true, ret);
412 ScreenPowerState stateGet = ScreenManager::GetInstance().GetScreenPower(defaultId_);
413 if (stateGet == stateToSet) {
414 ASSERT_EQ(stateGet, stateToSet);
415 }
416 }
417
418 /**
419 * @tc.name: window_life_cycle_001
420 * @tc.desc: Add a window and then call SuspendEnd and check window state; Notify unlock and check window state
421 * @tc.type: FUNC
422 */
423 HWTEST_F(DisplayPowerTest, window_life_cycle_001, TestSize.Level1)
424 {
425 sptr<WindowOption> option = new WindowOption();
426 sptr<Window> window = Window::Create("window1", option, nullptr);
427 if (window == nullptr) {
428 return;
429 }
430 EXPECT_EQ(WMError::WM_OK, window->Show());
431
432 DisplayManager::GetInstance().SuspendBegin(PowerStateChangeReason::POWER_BUTTON);
433 usleep(SLEEP_TIME_IN_US);
434 ASSERT_EQ(false, window->GetWindowState() == WindowState::STATE_SHOWN);
435
436 DisplayManager::GetInstance().NotifyDisplayEvent(DisplayEvent::UNLOCK);
437 usleep(SLEEP_TIME_IN_US);
438 ASSERT_EQ(true, window->GetWindowState() == WindowState::STATE_SHOWN);
439
440 window->Destroy();
441 }
442 } // namespace
443 } // namespace Rosen
444 } // namespace OHOS