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 // gtest
17 #include <gtest/gtest.h>
18 #include "wm_common.h"
19 #include "window_manager.h"
20 #include "window_test_utils.h"
21 using namespace testing;
22 using namespace testing::ext;
23 
24 namespace OHOS {
25 namespace Rosen {
26 namespace {
27 constexpr HiviewDFX::HiLogLabel LABEL = {LOG_CORE, HILOG_DOMAIN_WINDOW, "WindowFocusTest"};
28 }
29 
30 using Utils = WindowTestUtils;
31 const int WAIT_ASYNC_US = 100000;  // 100000us
32 
33 class TestFocusChangedListener : public IFocusChangedListener {
34 public:
35     uint32_t focusedWindow_ = INVALID_WINDOW_ID;
36     uint32_t unfocusedWindow_ = INVALID_WINDOW_ID;
37     void OnFocused(const sptr<FocusChangeInfo>& focusChangeInfo) override;
38     void OnUnfocused(const sptr<FocusChangeInfo>& focusChangeInfo) override;
39 };
40 
41 class WindowFocusTest : public testing::Test {
42 public:
43     static void SetUpTestCase();
44     static void TearDownTestCase();
45     virtual void SetUp() override;
46     virtual void TearDown() override;
47     static sptr<TestFocusChangedListener> testFocusChangedListener_;
48     Utils::TestWindowInfo fullScreenAppInfo_;
49     Utils::TestWindowInfo floatAppInfo_;
50     Utils::TestWindowInfo subAppInfo_;
51 };
52 
53 sptr<TestFocusChangedListener> WindowFocusTest::testFocusChangedListener_ =
54     new TestFocusChangedListener();
55 
OnFocused(const sptr<FocusChangeInfo>& focusChangeInfo)56 void TestFocusChangedListener::OnFocused(const sptr<FocusChangeInfo>& focusChangeInfo)
57 {
58     WLOGI("TestFocusChangedListener Focused ID: %{public}u", focusChangeInfo->windowId_);
59     focusedWindow_ = focusChangeInfo->windowId_;
60 }
61 
OnUnfocused(const sptr<FocusChangeInfo>& focusChangeInfo)62 void TestFocusChangedListener::OnUnfocused(const sptr<FocusChangeInfo>& focusChangeInfo)
63 {
64     WLOGI("TestFocusChangedListener Unfocused ID: %{public}u", focusChangeInfo->windowId_);
65     unfocusedWindow_ = focusChangeInfo->windowId_;
66 }
67 
SetUpTestCase()68 void WindowFocusTest::SetUpTestCase()
69 {
70     auto display = DisplayManager::GetInstance().GetDisplayById(0);
71     ASSERT_TRUE((display != nullptr));
72     WLOGI("GetDefaultDisplay: id %{public}" PRIu64", w %{public}d, h %{public}d, fps %{public}u",
73         display->GetId(), display->GetWidth(), display->GetHeight(), display->GetRefreshRate());
74     Rect displayRect = {0, 0, display->GetWidth(), display->GetHeight()};
75     Utils::InitByDisplayRect(displayRect);
76 }
77 
TearDownTestCase()78 void WindowFocusTest::TearDownTestCase()
79 {
80 }
81 
SetUp()82 void WindowFocusTest::SetUp()
83 {
84     fullScreenAppInfo_ = {
85             .name = "FullWindow",
86             .rect = Utils::customAppRect_,
87             .type = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW,
88             .mode = WindowMode::WINDOW_MODE_FULLSCREEN,
89             .needAvoid = false,
90             .parentLimit = false,
91             .showWhenLocked = true,
92             .parentId = INVALID_WINDOW_ID,
93     };
94     floatAppInfo_ = {
95             .name = "ParentWindow",
96             .rect = Utils::customAppRect_,
97             .type = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW,
98             .mode = WindowMode::WINDOW_MODE_FLOATING,
99             .needAvoid = false,
100             .parentLimit = false,
101             .showWhenLocked = true,
102             .parentId = INVALID_WINDOW_ID,
103     };
104     subAppInfo_ = {
105             .name = "SubWindow",
106             .rect = Utils::customAppRect_,
107             .type = WindowType::WINDOW_TYPE_APP_SUB_WINDOW,
108             .mode = WindowMode::WINDOW_MODE_FLOATING,
109             .needAvoid = false,
110             .parentLimit = false,
111             .showWhenLocked = false,
112             .parentId = INVALID_WINDOW_ID,
113     };
114     WindowManager::GetInstance().RegisterFocusChangedListener(testFocusChangedListener_);
115 }
116 
TearDown()117 void WindowFocusTest::TearDown()
118 {
119     WindowManager::GetInstance().UnregisterFocusChangedListener(testFocusChangedListener_);
120 }
121 
122 namespace {
123 /**
124  * @tc.name: FocusChangedTest01
125  * @tc.desc: add main window and sub window and show it to test focus
126  * @tc.type: FUNC
127  */
HWTEST_F(WindowFocusTest, FocusChangedTest01, Function | MediumTest | Level3)128 HWTEST_F(WindowFocusTest, FocusChangedTest01, Function | MediumTest | Level3)
129 {
130     fullScreenAppInfo_.name = "FocusChangedTest01_1";
131     fullScreenAppInfo_.focusable_ = false;
132     const sptr<Window>& window1 = Utils::CreateTestWindow(fullScreenAppInfo_);
133     if (window1 == nullptr) {
134         return;
135     }
136     ASSERT_NE(nullptr, window1);
137 
138     floatAppInfo_.name = "FocusChangedTest01_2";
139     floatAppInfo_.rect = { 10, 200, 300, 400 };
140     const sptr<Window>& window2 = Utils::CreateTestWindow(floatAppInfo_);
141     if (window2 == nullptr) {
142         return;
143     }
144     ASSERT_NE(nullptr, window2);
145 
146     floatAppInfo_.name = "FocusChangedTest01_3";
147     floatAppInfo_.rect = { 250, 150, 300, 500 };
148     const sptr<Window>& window3 = Utils::CreateTestWindow(floatAppInfo_);
149     if (window3 == nullptr) {
150         return;
151     }
152     ASSERT_NE(nullptr, window3);
153 
154     subAppInfo_.name = "FocusChangedTest01_4";
155     subAppInfo_.rect = { 400, 200, 100, 100 };
156     subAppInfo_.parentId = window3->GetWindowId();
157     const sptr<Window>& subWindow = Utils::CreateTestWindow(subAppInfo_);
158     ASSERT_NE(nullptr, subWindow);
159     ASSERT_EQ(WMError::WM_OK, window3->Show());
160     // Await 100ms and get callback result in listener.
161     usleep(WAIT_ASYNC_US);
162     ASSERT_EQ(window3->GetWindowId(), testFocusChangedListener_->focusedWindow_);
163 
164     ASSERT_EQ(WMError::WM_OK, window1->Show());
165     // Await 100ms and get callback result in listener.
166     usleep(WAIT_ASYNC_US);
167     ASSERT_EQ(window3->GetWindowId(), testFocusChangedListener_->focusedWindow_);
168 
169     ASSERT_EQ(WMError::WM_OK, window2->Show());
170     // Await 100ms and get callback result in listener.
171     usleep(WAIT_ASYNC_US);
172     ASSERT_EQ(window3->GetWindowId(), testFocusChangedListener_->unfocusedWindow_);
173     ASSERT_EQ(window2->GetWindowId(), testFocusChangedListener_->focusedWindow_);
174 
175     ASSERT_EQ(WMError::WM_OK, subWindow->Show());
176     // Await 100ms and get callback result in listener.
177     usleep(WAIT_ASYNC_US);
178     ASSERT_EQ(window2->GetWindowId(), testFocusChangedListener_->unfocusedWindow_);
179     ASSERT_EQ(subWindow->GetWindowId(), testFocusChangedListener_->focusedWindow_);
180 
181     window1->Destroy();
182     window2->Destroy();
183     window3->Destroy();
184     subWindow->Destroy();
185 }
186 
187 /**
188  * @tc.name: FocusChangedTest02
189  * @tc.desc: hide focused window to test focus
190  * @tc.type: FUNC
191  */
HWTEST_F(WindowFocusTest, FocusChangedTest02, Function | MediumTest | Level3)192 HWTEST_F(WindowFocusTest, FocusChangedTest02, Function | MediumTest | Level3)
193 {
194     floatAppInfo_.name = "FocusChangedTest02_1";
195     floatAppInfo_.rect = { 10, 200, 300, 400 };
196     const sptr<Window>& mainWindow = Utils::CreateTestWindow(floatAppInfo_);
197     if (mainWindow == nullptr) {
198         return;
199     }
200     ASSERT_NE(nullptr, mainWindow);
201     ASSERT_EQ(WMError::WM_OK, mainWindow->Show());
202 
203     subAppInfo_.name = "FocusChangedTest02_2";
204     subAppInfo_.rect = { 400, 200, 100, 100 };
205     subAppInfo_.parentId = mainWindow->GetWindowId();
206     const sptr<Window>& subWindow = Utils::CreateTestWindow(subAppInfo_);
207     if (subWindow == nullptr) {
208         return;
209     }
210     ASSERT_NE(nullptr, subWindow);
211     ASSERT_EQ(WMError::WM_OK, subWindow->Show());
212     usleep(WAIT_ASYNC_US);
213     ASSERT_EQ(subWindow->GetWindowId(), testFocusChangedListener_->focusedWindow_);
214 
215     ASSERT_EQ(WMError::WM_OK, subWindow->Hide());
216     // Await 100ms and get callback result in listener.
217     usleep(WAIT_ASYNC_US);
218     ASSERT_EQ(mainWindow->GetWindowId(), testFocusChangedListener_->focusedWindow_);
219 
220     mainWindow->Destroy();
221     subWindow->Destroy();
222 }
223 
224 /**
225  * @tc.name: FocusChangedTest03
226  * @tc.desc: hide focused window to test focus
227  * @tc.type: FUNC
228  */
HWTEST_F(WindowFocusTest, FocusChangedTest03, Function | MediumTest | Level3)229 HWTEST_F(WindowFocusTest, FocusChangedTest03, Function | MediumTest | Level3)
230 {
231     floatAppInfo_.name = "FocusChangedTest03_1";
232     floatAppInfo_.rect = { 10, 200, 300, 400 };
233     const sptr<Window>& mainWindow1 = Utils::CreateTestWindow(floatAppInfo_);
234     if (mainWindow1 == nullptr) {
235         return;
236     }
237     ASSERT_NE(nullptr, mainWindow1);
238     ASSERT_EQ(WMError::WM_OK, mainWindow1->Show());
239 
240     subAppInfo_.name = "FocusChangedTest03_2";
241     subAppInfo_.rect = { 400, 200, 100, 100 };
242     subAppInfo_.parentId = mainWindow1->GetWindowId();
243     const sptr<Window>& aboveSubWindow = Utils::CreateTestWindow(subAppInfo_);
244     ASSERT_NE(nullptr, aboveSubWindow);
245     ASSERT_EQ(WMError::WM_OK, aboveSubWindow->Show());
246 
247     floatAppInfo_.name = "FocusChangedTest03_3";
248     floatAppInfo_.rect = { 200, 200, 100, 100 };
249     const sptr<Window>& mainWindow2 = Utils::CreateTestWindow(floatAppInfo_);
250     if (mainWindow2 == nullptr) {
251         return;
252     }
253     ASSERT_NE(nullptr, mainWindow2);
254     ASSERT_EQ(WMError::WM_OK, mainWindow2->Show());
255     usleep(WAIT_ASYNC_US);
256     ASSERT_EQ(mainWindow2->GetWindowId(), testFocusChangedListener_->focusedWindow_);
257 
258     ASSERT_EQ(WMError::WM_OK, mainWindow2->Hide());
259     // Await 100ms and get callback result in listener.
260     usleep(WAIT_ASYNC_US);
261     ASSERT_EQ(mainWindow2->GetWindowId(), testFocusChangedListener_->unfocusedWindow_);
262     ASSERT_EQ(aboveSubWindow->GetWindowId(), testFocusChangedListener_->focusedWindow_);
263 
264     mainWindow1->Destroy();
265     mainWindow2->Destroy();
266     aboveSubWindow->Destroy();
267 }
268 
269 /**
270  * @tc.name: FocusChangedTest04
271  * @tc.desc: hide focused window to test focus
272  * @tc.type: FUNC
273  */
HWTEST_F(WindowFocusTest, FocusChangedTest04, Function | MediumTest | Level3)274 HWTEST_F(WindowFocusTest, FocusChangedTest04, Function | MediumTest | Level3)
275 {
276     floatAppInfo_.name = "FocusChangedTest04_1";
277     floatAppInfo_.rect = { 10, 200, 300, 400 };
278     const sptr<Window>& mainWindow1 = Utils::CreateTestWindow(floatAppInfo_);
279     if (mainWindow1 == nullptr) {
280         return;
281     }
282     ASSERT_NE(nullptr, mainWindow1);
283     ASSERT_EQ(WMError::WM_OK, mainWindow1->Show());
284 
285     subAppInfo_.name = "FocusChangedTest04_2";
286     subAppInfo_.rect = { 400, 200, 100, 100 };
287     subAppInfo_.parentId = mainWindow1->GetWindowId();
288     subAppInfo_.type = WindowType::WINDOW_TYPE_MEDIA;
289     const sptr<Window>& belowSubWindow = Utils::CreateTestWindow(subAppInfo_);
290     if (belowSubWindow == nullptr) {
291         return;
292     }
293     ASSERT_NE(nullptr, belowSubWindow);
294     ASSERT_EQ(WMError::WM_OK, belowSubWindow->Show());
295 
296     floatAppInfo_.name = "FocusChangedTest04_3";
297     floatAppInfo_.rect = { 200, 200, 100, 100 };
298     const sptr<Window>& mainWindow2 = Utils::CreateTestWindow(floatAppInfo_);
299     if (mainWindow2 == nullptr) {
300         return;
301     }
302     ASSERT_NE(nullptr, mainWindow2);
303     ASSERT_EQ(WMError::WM_OK, mainWindow2->Show());
304     usleep(WAIT_ASYNC_US);
305     ASSERT_EQ(mainWindow2->GetWindowId(), testFocusChangedListener_->focusedWindow_);
306 
307     ASSERT_EQ(WMError::WM_OK, mainWindow2->Hide());
308     // Await 100ms and get callback result in listener.
309     usleep(WAIT_ASYNC_US);
310     ASSERT_EQ(mainWindow2->GetWindowId(), testFocusChangedListener_->unfocusedWindow_);
311     ASSERT_EQ(mainWindow1->GetWindowId(), testFocusChangedListener_->focusedWindow_);
312 
313     mainWindow1->Destroy();
314     mainWindow2->Destroy();
315     belowSubWindow->Destroy();
316 }
317 
318 /**
319  * @tc.name: FocusChangedTest05
320  * @tc.desc: hide focused window to test focus
321  * @tc.type: FUNC
322  */
HWTEST_F(WindowFocusTest, FocusChangedTest05, Function | MediumTest | Level3)323 HWTEST_F(WindowFocusTest, FocusChangedTest05, Function | MediumTest | Level3)
324 {
325     floatAppInfo_.name = "FocusChangedTest05_1";
326     floatAppInfo_.rect = { 10, 200, 300, 400 };
327     const sptr<Window>& mainWindow1 = Utils::CreateTestWindow(floatAppInfo_);
328     if (mainWindow1 == nullptr) {
329         return;
330     }
331     ASSERT_NE(nullptr, mainWindow1);
332     ASSERT_EQ(WMError::WM_OK, mainWindow1->Show());
333 
334     floatAppInfo_.name = "FocusChangedTest05_2";
335     floatAppInfo_.rect = { 200, 200, 100, 100 };
336     const sptr<Window>& mainWindow2 = Utils::CreateTestWindow(floatAppInfo_);
337     if (mainWindow2 == nullptr) {
338         return;
339     }
340     ASSERT_NE(nullptr, mainWindow2);
341     ASSERT_EQ(WMError::WM_OK, mainWindow2->Show());
342 
343     subAppInfo_.name = "FocusChangedTest05_3";
344     subAppInfo_.rect = { 400, 200, 100, 100 };
345     subAppInfo_.parentId = mainWindow2->GetWindowId();
346     subAppInfo_.type = WindowType::WINDOW_TYPE_MEDIA;
347     const sptr<Window>& belowSubWindow = Utils::CreateTestWindow(subAppInfo_);
348     if (belowSubWindow == nullptr) {
349         return;
350     }
351     ASSERT_NE(nullptr, belowSubWindow);
352     ASSERT_EQ(WMError::WM_OK, belowSubWindow->Show());
353     usleep(WAIT_ASYNC_US);
354     ASSERT_EQ(belowSubWindow->GetWindowId(), testFocusChangedListener_->focusedWindow_);
355 
356     ASSERT_EQ(WMError::WM_OK, belowSubWindow->Hide());
357     // Await 100ms and get callback result in listener.
358     usleep(WAIT_ASYNC_US);
359     ASSERT_EQ(belowSubWindow->GetWindowId(), testFocusChangedListener_->unfocusedWindow_);
360     ASSERT_EQ(mainWindow1->GetWindowId(), testFocusChangedListener_->focusedWindow_);
361 
362     ASSERT_EQ(WMError::WM_OK, belowSubWindow->Show());
363     usleep(WAIT_ASYNC_US);
364     ASSERT_EQ(mainWindow1->GetWindowId(), testFocusChangedListener_->unfocusedWindow_);
365     ASSERT_EQ(belowSubWindow->GetWindowId(), testFocusChangedListener_->focusedWindow_);
366     ASSERT_EQ(WMError::WM_OK, mainWindow2->Hide());
367     usleep(WAIT_ASYNC_US);
368     ASSERT_EQ(belowSubWindow->GetWindowId(), testFocusChangedListener_->unfocusedWindow_);
369     ASSERT_EQ(mainWindow1->GetWindowId(), testFocusChangedListener_->focusedWindow_);
370 
371     mainWindow1->Destroy();
372     mainWindow2->Destroy();
373     belowSubWindow->Destroy();
374 }
375 
376 /**
377 * @tc.name: FocusChangedTest06
378 * @tc.desc: hide unfocused window to test focus
379 * @tc.type: FUNC
380 */
HWTEST_F(WindowFocusTest, FocusChangedTest06, Function | MediumTest | Level3)381 HWTEST_F(WindowFocusTest, FocusChangedTest06, Function | MediumTest | Level3)
382 {
383     floatAppInfo_.name = "FocusChangedTest06_1";
384     floatAppInfo_.rect = { 10, 200, 300, 400 };
385     const sptr<Window>& mainWindow = Utils::CreateTestWindow(floatAppInfo_);
386     if (mainWindow == nullptr) {
387         return;
388     }
389     ASSERT_NE(nullptr, mainWindow);
390     ASSERT_EQ(WMError::WM_OK, mainWindow->Show());
391 
392     subAppInfo_.name = "FocusChangedTest06_2";
393     subAppInfo_.rect = { 100, 200, 100, 100 };
394     subAppInfo_.parentId = mainWindow->GetWindowId();
395     subAppInfo_.type = WindowType::WINDOW_TYPE_MEDIA;
396     const sptr<Window>& belowSubWindow = Utils::CreateTestWindow(subAppInfo_);
397     if (belowSubWindow == nullptr) {
398         return;
399     }
400     ASSERT_NE(nullptr, belowSubWindow);
401     ASSERT_EQ(WMError::WM_OK, belowSubWindow->Show());
402 
403     subAppInfo_.name = "FocusChangedTest06_3";
404     subAppInfo_.rect = { 400, 200, 100, 100 };
405     subAppInfo_.parentId = mainWindow->GetWindowId();
406     subAppInfo_.type = WindowType::WINDOW_TYPE_APP_SUB_WINDOW;
407     const sptr<Window>& aboveSubWindow = Utils::CreateTestWindow(subAppInfo_);
408     ASSERT_NE(nullptr, aboveSubWindow);
409     ASSERT_EQ(WMError::WM_OK, aboveSubWindow->Show());
410     usleep(WAIT_ASYNC_US);
411     ASSERT_EQ(aboveSubWindow->GetWindowId(), testFocusChangedListener_->focusedWindow_);
412 
413     ASSERT_EQ(WMError::WM_OK, belowSubWindow->Hide());
414     // Await 100ms and get callback result in listener.
415     usleep(WAIT_ASYNC_US);
416     ASSERT_EQ(aboveSubWindow->GetWindowId(), testFocusChangedListener_->focusedWindow_);
417 }
418 
419 /**
420 * @tc.name: FocusChangedTest07
421 * @tc.desc: destroy focused window to test focus
422 * @tc.type: FUNC
423 */
HWTEST_F(WindowFocusTest, FocusChangedTest07, Function | MediumTest | Level3)424 HWTEST_F(WindowFocusTest, FocusChangedTest07, Function | MediumTest | Level3)
425 {
426     floatAppInfo_.name = "FocusChangedTest07_1";
427     floatAppInfo_.rect = { 10, 200, 300, 400 };
428     const sptr<Window>& mainWindow1 = Utils::CreateTestWindow(floatAppInfo_);
429     if (mainWindow1 == nullptr) {
430         return;
431     }
432     ASSERT_NE(nullptr, mainWindow1);
433     ASSERT_EQ(WMError::WM_OK, mainWindow1->Show());
434 
435     floatAppInfo_.name = "FocusChangedTest07_2";
436     floatAppInfo_.rect = { 250, 150, 300, 500 };
437     const sptr<Window>& mainWindow2 = Utils::CreateTestWindow(floatAppInfo_);
438     if (mainWindow2 == nullptr) {
439         return;
440     }
441     ASSERT_NE(nullptr, mainWindow2);
442     ASSERT_EQ(WMError::WM_OK, mainWindow2->Show());
443 
444     floatAppInfo_.name = "FocusChangedTest07_3";
445     floatAppInfo_.rect = { 300, 400, 10, 400 };
446     const sptr<Window>& mainWindow3 = Utils::CreateTestWindow(floatAppInfo_);
447     if (mainWindow3 == nullptr) {
448         return;
449     }
450     ASSERT_NE(nullptr, mainWindow3);
451     ASSERT_EQ(WMError::WM_OK, mainWindow3->Show());
452 
453     subAppInfo_.name = "FocusChangedTest07_4";
454     subAppInfo_.rect = { 20, 100, 100, 100 };
455     subAppInfo_.parentId = mainWindow1->GetWindowId();
456     subAppInfo_.type = WindowType::WINDOW_TYPE_MEDIA;
457     const sptr<Window>& belowSubWindow1 = Utils::CreateTestWindow(subAppInfo_);
458     if (belowSubWindow1 == nullptr) {
459         return;
460     }
461     ASSERT_NE(nullptr, belowSubWindow1);
462 
463     subAppInfo_.name = "FocusChangedTest07_5";
464     subAppInfo_.rect = { 400, 200, 100, 100 };
465     subAppInfo_.parentId = mainWindow2->GetWindowId();
466     subAppInfo_.type = WindowType::WINDOW_TYPE_APP_SUB_WINDOW;
467     const sptr<Window>& aboveSubWindow = Utils::CreateTestWindow(subAppInfo_);
468     if (aboveSubWindow == nullptr) {
469         return;
470     }
471     ASSERT_NE(nullptr, aboveSubWindow);
472 
473     subAppInfo_.name = "FocusChangedTest07_6";
474     subAppInfo_.rect = { 310, 410, 100, 100 };
475     subAppInfo_.parentId = mainWindow3->GetWindowId();
476     subAppInfo_.type = WindowType::WINDOW_TYPE_MEDIA;
477     const sptr<Window>& belowSubWindow2 = Utils::CreateTestWindow(subAppInfo_);
478     if (belowSubWindow2 == nullptr) {
479         return;
480     }
481     ASSERT_NE(nullptr, belowSubWindow2);
482 
483     ASSERT_EQ(WMError::WM_OK, aboveSubWindow->Show());
484     ASSERT_EQ(WMError::WM_OK, belowSubWindow2->Show());
485     ASSERT_EQ(WMError::WM_OK, belowSubWindow1->Show());
486     usleep(WAIT_ASYNC_US);
487     ASSERT_EQ(belowSubWindow1->GetWindowId(), testFocusChangedListener_->focusedWindow_);
488 
489     ASSERT_EQ(WMError::WM_OK, mainWindow1->Destroy());
490     // Await 100ms and get callback result in listener.
491     usleep(WAIT_ASYNC_US);
492     ASSERT_EQ(belowSubWindow1->GetWindowId(), testFocusChangedListener_->unfocusedWindow_);
493     ASSERT_EQ(mainWindow3->GetWindowId(), testFocusChangedListener_->focusedWindow_);
494 
495     ASSERT_EQ(WMError::WM_OK, mainWindow3->Destroy());
496     usleep(WAIT_ASYNC_US);
497     ASSERT_EQ(mainWindow3->GetWindowId(), testFocusChangedListener_->unfocusedWindow_);
498     ASSERT_EQ(aboveSubWindow->GetWindowId(), testFocusChangedListener_->focusedWindow_);
499 
500     ASSERT_EQ(WMError::WM_OK, aboveSubWindow->Destroy());
501     usleep(WAIT_ASYNC_US);
502     ASSERT_EQ(aboveSubWindow->GetWindowId(), testFocusChangedListener_->unfocusedWindow_);
503     ASSERT_EQ(mainWindow2->GetWindowId(), testFocusChangedListener_->focusedWindow_);
504 
505     mainWindow2->Destroy();
506 }
507 
508 /**
509 * @tc.name: FocusChangedTest08
510 * @tc.desc: destroy unfocused window to test focus
511 * @tc.type: FUNC
512 */
HWTEST_F(WindowFocusTest, FocusChangedTest08, Function | MediumTest | Level3)513 HWTEST_F(WindowFocusTest, FocusChangedTest08, Function | MediumTest | Level3)
514 {
515     floatAppInfo_.name = "FocusChangedTest08_1";
516     floatAppInfo_.rect = { 10, 200, 300, 400 };
517     const sptr<Window>& mainWindow1 = Utils::CreateTestWindow(floatAppInfo_);
518     if (mainWindow1 == nullptr) {
519         return;
520     }
521     ASSERT_NE(nullptr, mainWindow1);
522     ASSERT_EQ(WMError::WM_OK, mainWindow1->Show());
523 
524     floatAppInfo_.name = "FocusChangedTest08_2";
525     floatAppInfo_.rect = { 250, 150, 300, 500 };
526     const sptr<Window>& mainWindow2 = Utils::CreateTestWindow(floatAppInfo_);
527     if (mainWindow2 == nullptr) {
528         return;
529     }
530     ASSERT_NE(nullptr, mainWindow2);
531     ASSERT_EQ(WMError::WM_OK, mainWindow2->Show());
532 
533     subAppInfo_.name = "FocusChangedTest08_3";
534     subAppInfo_.rect = { 20, 100, 100, 100 };
535     subAppInfo_.parentId = mainWindow1->GetWindowId();
536     subAppInfo_.type = WindowType::WINDOW_TYPE_MEDIA;
537     const sptr<Window>& belowSubWindow = Utils::CreateTestWindow(subAppInfo_);
538     if (belowSubWindow == nullptr) {
539         return;
540     }
541     ASSERT_NE(nullptr, belowSubWindow);
542     ASSERT_EQ(WMError::WM_OK, belowSubWindow->Show());
543     usleep(WAIT_ASYNC_US);
544     ASSERT_EQ(belowSubWindow->GetWindowId(), testFocusChangedListener_->focusedWindow_);
545 
546     ASSERT_EQ(WMError::WM_OK, mainWindow2->Destroy());
547     // Await 100ms and get callback result in listener.
548     usleep(WAIT_ASYNC_US);
549     ASSERT_EQ(belowSubWindow->GetWindowId(), testFocusChangedListener_->focusedWindow_);
550 
551     mainWindow1->Destroy();
552 }
553 
554 /**
555  * @tc.name: WindowShowWithoutFocusTest
556  * @tc.desc: add main window and sub window and show it to test focus
557  * @tc.type: FUNC
558  */
HWTEST_F(WindowFocusTest, WindowShowWithoutFocusTest, Function | MediumTest | Level3)559 HWTEST_F(WindowFocusTest, WindowShowWithoutFocusTest, Function | MediumTest | Level3)
560 {
561     fullScreenAppInfo_.name = "WindowShowWithoutFocusTest_1";
562     fullScreenAppInfo_.focusable_ = false;
563     const sptr<Window>& window1 = Utils::CreateTestWindow(fullScreenAppInfo_);
564     ASSERT_NE(nullptr, window1);
565 
566     floatAppInfo_.name = "WindowShowWithoutFocusTest_2";
567     floatAppInfo_.rect = { 10, 200, 300, 400 };
568     const sptr<Window>& window2 = Utils::CreateTestWindow(floatAppInfo_);
569     ASSERT_NE(nullptr, window2);
570 
571     subAppInfo_.name = "WindowShowWithoutFocusTest_3";
572     subAppInfo_.rect = { 400, 200, 100, 100 };
573     subAppInfo_.parentId = window2->GetWindowId();
574     const sptr<Window>& subWindow = Utils::CreateTestWindow(subAppInfo_);
575     ASSERT_NE(nullptr, subWindow);
576 
577     ASSERT_EQ(WMError::WM_OK, window1->Show());
578     // Await 100ms and get callback result in listener.
579     usleep(WAIT_ASYNC_US);
580     ASSERT_EQ(window1->GetWindowId(), testFocusChangedListener_->focusedWindow_);
581 
582     ASSERT_EQ(WMError::WM_OK, window2->Show(0, false, false));
583     // Await 100ms and get callback result in listener.
584     usleep(WAIT_ASYNC_US);
585     ASSERT_EQ(window1->GetWindowId(), testFocusChangedListener_->focusedWindow_);
586 
587     ASSERT_EQ(WMError::WM_OK, subWindow->Show(0, false, false));
588     // Await 100ms and get callback result in listener.
589     usleep(WAIT_ASYNC_US);
590     ASSERT_EQ(window1->GetWindowId(), testFocusChangedListener_->focusedWindow_);
591 
592     window1->Destroy();
593     window2->Destroy();
594     subWindow->Destroy();
595 }
596 }
597 } // namespace Rosen
598 } // namespace OHOS
599