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