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 "common/include/window_session_property.h"
17 #include <gtest/gtest.h>
18 #include "input_manager.h"
19 #include <parameter.h>
20 #include <parameters.h>
21 #include "session_manager/include/scene_session_dirty_manager.h"
22 #include "screen_session_manager_client/include/screen_session_manager_client.h"
23 #include "scene_input_manager.h"
24 #include "session/host/include/scene_session.h"
25 #include "session_manager/include/scene_session_manager.h"
26 #include "transaction/rs_uiextension_data.h"
27 #include "window_helper.h"
28
29 using namespace testing;
30 using namespace testing::ext;
31
32 namespace OHOS {
33 namespace Rosen {
34
35 class SceneSessionDirtyManagerTest2 : public testing::Test {
36 public:
37 static void SetUpTestCase();
38 static void TearDownTestCase();
39 void SetUp() override;
40 void TearDown() override;
41 static constexpr uint32_t WAIT_SYNC_IN_NS = 500000;
42 };
43
44 std::shared_ptr<SceneSessionDirtyManager> manager_;
45 sptr<SceneSessionManager> ssm_;
46 std::shared_ptr<SceneInputManager> sim_;
47
SetUpTestCase()48 void SceneSessionDirtyManagerTest2::SetUpTestCase()
49 {
50 ssm_ = &SceneSessionManager::GetInstance();
51 ssm_->sceneSessionMap_.clear();
52 sim_ = std::make_shared<SceneInputManager>();
53 }
54
TearDownTestCase()55 void SceneSessionDirtyManagerTest2::TearDownTestCase()
56 {
57 ssm_ = nullptr;
58 }
59
SetUp()60 void SceneSessionDirtyManagerTest2::SetUp()
61 {
62 manager_ = std::make_shared<SceneSessionDirtyManager>();
63 }
64
TearDown()65 void SceneSessionDirtyManagerTest2::TearDown()
66 {
67 usleep(WAIT_SYNC_IN_NS);
68 manager_ = nullptr;
69 }
70
71 namespace {
72
InitSessionInfo(MMI::DisplayInfo & displayedInfo,MMI::WindowInfo & windowInfo)73 void InitSessionInfo(MMI::DisplayInfo& displayedInfo, MMI::WindowInfo& windowInfo)
74 {
75 displayedInfo = {
76 .id = 42,
77 .x = 0,
78 .y = 0,
79 .width = 1270,
80 .height = 2240
81 };
82
83 windowInfo = {
84 .id = 43,
85 .pid = 433,
86 .displayId = 42,
87 .zOrder = 30.0,
88 .area = {0, 0, 1000, 1200}
89 };
90 }
91
92 /**
93 * @tc.name: Init sceneSession
94 * @tc.desc: Init sceneSession
95 * @tc.type: FUNC
96 */
InitSceneSession(sptr<SceneSession> & sceneSession,int32_t pid,int windowId,WindowType propertyType)97 void InitSceneSession(sptr<SceneSession> &sceneSession, int32_t pid, int windowId, WindowType propertyType)
98 {
99 sptr<WindowSessionProperty> windowSessionProperty = sptr<WindowSessionProperty>::MakeSptr();
100 ASSERT_NE(windowSessionProperty, nullptr);
101 uint64_t displayId = 1;
102 windowSessionProperty->SetDisplayId(displayId);
103 windowSessionProperty->SetWindowMode(WindowMode::WINDOW_MODE_UNDEFINED);
104 windowSessionProperty->SetMaximizeMode(MaximizeMode::MODE_AVOID_SYSTEM_BAR);
105 windowSessionProperty->SetWindowType(propertyType);
106 windowSessionProperty->topmost_ = false;
107 windowSessionProperty->SetPersistentId(windowId);
108 sceneSession->SetSessionProperty(windowSessionProperty);
109
110 WSRect windowRect = {0, 0, 1270, 2700};
111 sceneSession->SetSessionRect(windowRect);
112 sceneSession->SetVisibilityChangedDetectFunc([](int32_t pid, bool isVisible, bool newIsVisible) {
113 return;
114 });
115 sceneSession->SetCallingPid(pid);
116 int32_t uid = 1315;
117 sceneSession->SetCallingUid(uid);
118 }
119
120 /**
121 * @tc.name: GetWindowInfoWithoutHotArea
122 * @tc.desc: windowInfo without hotAreas information
123 * @tc.type: FUNC
124 */
125 HWTEST_F(SceneSessionDirtyManagerTest2, GetWindowInfoWithoutHotArea, Function | SmallTest | Level2)
126 {
127 SessionInfo info;
128 info.abilityName_ = "TestWithoutHotArea";
129 info.bundleName_ = "TestWithoutHotArea";
130 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
131 ASSERT_NE(sceneSession, nullptr);
132 sptr<WindowSessionProperty> windowSessionProperty = sptr<WindowSessionProperty>::MakeSptr();
133 ASSERT_NE(windowSessionProperty, nullptr);
134 windowSessionProperty->SetWindowType(WindowType::WINDOW_TYPE_GLOBAL_SEARCH);
135 sceneSession->InitSessionPropertyWhenConnect(windowSessionProperty);
136 WSRect windowRect = {0, 0, 1270, 2700};
137 sceneSession->SetSessionRect(windowRect);
138 sceneSession->globalRect_ = windowRect;
139 // set hotArea without info
140 std::vector<MMI::Rect> touchHotAreas;
141 std::vector<MMI::Rect> pointerHotAreas;
142 manager_->UpdateHotAreas(sceneSession, touchHotAreas, pointerHotAreas);
143 bool touchHotResult = touchHotAreas[0].x == 0 && touchHotAreas[0].y == 0 &&
144 touchHotAreas[0].width == 1270 && touchHotAreas[0].height == 2700;
145 ASSERT_EQ(touchHotResult, true);
146 bool pointerHotResult = pointerHotAreas[0].x == 0 && pointerHotAreas[0].y == 0 &&
147 pointerHotAreas[0].width == 1270 && pointerHotAreas[0].height == 2700;
148 ASSERT_EQ(pointerHotResult, true);
149 }
150
151 /**
152 * @tc.name: GetWindowInfoWithHotArea
153 * @tc.desc: windowInfo with hotAreas information
154 * @tc.type: FUNC
155 */
156 HWTEST_F(SceneSessionDirtyManagerTest2, GetWindowInfoWithHotArea, Function | SmallTest | Level2)
157 {
158 SessionInfo info;
159 info.abilityName_ = "TestWithHotArea";
160 info.bundleName_ = "TestWithHotArea";
161 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
162 ASSERT_NE(sceneSession, nullptr);
163 sptr<WindowSessionProperty> windowSessionProperty = sptr<WindowSessionProperty>::MakeSptr();
164 ASSERT_NE(windowSessionProperty, nullptr);
165 windowSessionProperty->SetWindowType(WindowType::WINDOW_TYPE_GLOBAL_SEARCH);
166 Rect rect = {0, 0, 300, 500};
167 std::vector<Rect> rects;
168 rects.emplace_back(rect);
169 // set touchHotArea and pointerHotArea info
170 windowSessionProperty->SetTouchHotAreas(rects);
171 sceneSession->InitSessionPropertyWhenConnect(windowSessionProperty);
172 WSRect windowRect = {0, 0, 1270, 2700};
173 sceneSession->SetSessionRect(windowRect);
174 std::vector<MMI::Rect> touchHotAreas;
175 std::vector<MMI::Rect> pointerHotAreas;
176 manager_->UpdateHotAreas(sceneSession, touchHotAreas, pointerHotAreas);
177 bool touchHotResult = touchHotAreas[0].x == 0 && touchHotAreas[0].y == 0 &&
178 touchHotAreas[0].width == 300 && touchHotAreas[0].height == 500;
179 ASSERT_EQ(touchHotResult, true);
180 bool pointerHotResult = pointerHotAreas[0].x == 0 && pointerHotAreas[0].y == 0 &&
181 pointerHotAreas[0].width == 300 && pointerHotAreas[0].height == 500;
182 ASSERT_EQ(pointerHotResult, true);
183 }
184
185 /**
186 * @tc.name: GetWindowInfoWithWindowTypeDialog
187 * @tc.desc: windowInfo with windowType dialog
188 * @tc.type: FUNC
189 */
190 HWTEST_F(SceneSessionDirtyManagerTest2, GetWindowInfoWithWindowTypeDialog, Function | SmallTest | Level2)
191 {
192 // init main window info
193 SessionInfo mainWindowInfo;
194 mainWindowInfo.abilityName_ = "TestMainWithType";
195 mainWindowInfo.bundleName_ = "TestMainWithType";
196 int32_t mainWindowId = 30;
197 sptr<SceneSession> sceneSessionMainWindow = sptr<SceneSession>::MakeSptr(mainWindowInfo, nullptr);
198 ASSERT_NE(sceneSessionMainWindow, nullptr);
199 sceneSessionMainWindow->zOrder_ = 55.0f;
200 sceneSessionMainWindow->persistentId_ = mainWindowId;
201 sceneSessionMainWindow->isVisible_ = true;
202 int32_t mainFlags = static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_WATER_MARK);
203 sceneSessionMainWindow->property_->SetWindowFlags(mainFlags);
204 int32_t mainWindowPid = 50;
205 InitSceneSession(sceneSessionMainWindow, mainWindowPid, mainWindowId, WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
206 // init sub window with window type dialog
207 SessionInfo dialogWindowInfo;
208 dialogWindowInfo.abilityName_ = "TestDialogWithType";
209 dialogWindowInfo.bundleName_ = "TestDialogWithType";
210 int32_t dialogWindowId = 31;
211 sptr<SceneSession> sceneSessionDialogWindow = sptr<SceneSession>::MakeSptr(dialogWindowInfo, nullptr);
212 ASSERT_NE(sceneSessionDialogWindow, nullptr);
213 sceneSessionDialogWindow->zOrder_ = 56.0f;
214 sceneSessionDialogWindow->persistentId_ = dialogWindowId;
215 sceneSessionDialogWindow->isVisible_ = true;
216 uint32_t flags = static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_IS_MODAL);
217 sceneSessionDialogWindow->property_->SetWindowFlags(flags);
218 int32_t dialogWindowPid = 51;
219 InitSceneSession(sceneSessionDialogWindow, dialogWindowPid, dialogWindowId, WindowType::WINDOW_TYPE_DIALOG);
220 sceneSessionDialogWindow->SetParentSession(sceneSessionMainWindow);
221 std::map<int32_t, sptr<SceneSession>> retSceneSessionMap;
222 retSceneSessionMap.insert(std::make_pair(mainWindowPid, sceneSessionMainWindow));
223 retSceneSessionMap.insert(std::make_pair(dialogWindowPid, sceneSessionDialogWindow));
224 ssm_->sceneSessionMap_ = retSceneSessionMap;
225 auto [windowInfoList, pixelMapList] = manager_->GetFullWindowInfoList();
226 ASSERT_EQ(windowInfoList.size(), 2);
227 bool windowTypeDialogResult = false;
228 for (MMI::WindowInfo windowInfo : windowInfoList) {
229 if (windowInfo.id == mainWindowId && windowInfo.agentWindowId == dialogWindowId &&
230 windowInfo.pid == dialogWindowPid) {
231 windowTypeDialogResult = true;
232 }
233 }
234 ASSERT_EQ(windowTypeDialogResult, true);
235 }
236
237 /**
238 * @tc.name: GetWindowInfoWithWindowTypeAppSub
239 * @tc.desc: windowInfo with window_Type_app_sub
240 * @tc.type: FUNC
241 */
242 HWTEST_F(SceneSessionDirtyManagerTest2, GetWindowInfoWithWindowTypeAppSub, Function | SmallTest | Level2)
243 {
244 // init main window info
245 SessionInfo mainWindowInfo;
246 mainWindowInfo.abilityName_ = "TestMainWithType";
247 mainWindowInfo.bundleName_ = "TestMainWithType";
248 int32_t mainWindowId = 32;
249 sptr<SceneSession> sceneSessionMainWindow = sptr<SceneSession>::MakeSptr(mainWindowInfo, nullptr);
250 ASSERT_NE(sceneSessionMainWindow, nullptr);
251 sceneSessionMainWindow->persistentId_ = mainWindowId;
252 sceneSessionMainWindow->isVisible_ = true;
253 int32_t mainFlags = static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_WATER_MARK);
254 sceneSessionMainWindow->property_->SetWindowFlags(mainFlags);
255 int32_t mainWindowPid = 52;
256 InitSceneSession(sceneSessionMainWindow, mainWindowPid, mainWindowId, WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
257 // init sub window with window type float
258 SessionInfo subWindowInfo;
259 subWindowInfo.abilityName_ = "TestSubWithType";
260 subWindowInfo.bundleName_ = "TestSubWithType";
261 int32_t subWindowId = 33;
262 sptr<SceneSession> sceneSessionSubWindow = sptr<SceneSession>::MakeSptr(subWindowInfo, nullptr);
263 ASSERT_NE(sceneSessionSubWindow, nullptr);
264 sceneSessionSubWindow->persistentId_ = subWindowId;
265 sceneSessionSubWindow->isVisible_ = true;
266 uint32_t flags = static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_IS_MODAL);
267 sceneSessionSubWindow->property_->SetWindowFlags(flags);
268 int32_t subWindowPid = 53;
269 InitSceneSession(sceneSessionSubWindow, subWindowPid, subWindowId, WindowType::WINDOW_TYPE_FLOAT);
270 sceneSessionSubWindow->SetParentSession(sceneSessionMainWindow);
271 std::map<int32_t, sptr<SceneSession>> retSceneSessionMap;
272 retSceneSessionMap.insert(std::make_pair(mainWindowPid, sceneSessionMainWindow));
273 retSceneSessionMap.insert(std::make_pair(subWindowPid, sceneSessionSubWindow));
274 ssm_->sceneSessionMap_ = retSceneSessionMap;
275 auto [windowInfoList, pixelMapList] = manager_->GetFullWindowInfoList();
276 ASSERT_EQ(windowInfoList.size(), 2);
277 bool windowTypeDialogResult = false;
278 for (MMI::WindowInfo windowInfo : windowInfoList) {
279 if (windowInfo.id == mainWindowId && windowInfo.agentWindowId == subWindowId &&
280 windowInfo.pid == subWindowPid) {
281 windowTypeDialogResult = true;
282 }
283 }
284 ASSERT_EQ(windowTypeDialogResult, false);
285 }
286
287 /**
288 * @tc.name: GetWindowInfoWithTypeKeyboardPanel
289 * @tc.desc: windowInfo with window_Type_keyboard panel
290 * @tc.type: FUNC
291 */
292 HWTEST_F(SceneSessionDirtyManagerTest2, GetWindowInfoWithTypeKeyboardPanel, Function | SmallTest | Level2)
293 {
294 SessionInfo mainWindowInfo;
295 mainWindowInfo.abilityName_ = "TestMainWithType";
296 mainWindowInfo.bundleName_ = "TestMainWithType";
297 int32_t mainWindowId = 34;
298 sptr<SceneSession> sceneSessionMainWindow = sptr<SceneSession>::MakeSptr(mainWindowInfo, nullptr);
299 ASSERT_NE(sceneSessionMainWindow, nullptr);
300 sceneSessionMainWindow->persistentId_ = mainWindowId;
301 sceneSessionMainWindow->isVisible_ = false;
302 uint32_t mainFlags = static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_WATER_MARK);
303 sceneSessionMainWindow->property_->SetWindowFlags(mainFlags);
304 int32_t mainWindowPid = 54;
305 // init sceneSession with windowType is window_type_keyBoard_panel
306 InitSceneSession(sceneSessionMainWindow, mainWindowPid, mainWindowId, WindowType::WINDOW_TYPE_KEYBOARD_PANEL);
307 std::map<int32_t, sptr<SceneSession>> retSceneSessionMap;
308 retSceneSessionMap.insert(std::make_pair(mainWindowPid, sceneSessionMainWindow));
309 ssm_->sceneSessionMap_ = retSceneSessionMap;
310 std::map<int32_t, sptr<SceneSession>> sceneSessionMap =
311 Rosen::SceneSessionManager::GetInstance().GetSceneSessionMap();
312 int32_t windowInfoSize = sceneSessionMap.size();
313 ASSERT_EQ(windowInfoSize, 0);
314 }
315
316 /**
317 * @tc.name: GetWindowInfoWithoutParentWindow
318 * @tc.desc: windowInfo without parent window
319 * @tc.type: FUNC
320 */
321 HWTEST_F(SceneSessionDirtyManagerTest2, GetWindowInfoWithoutParentWindow, Function | SmallTest | Level2)
322 {
323 SessionInfo subWindowInfo;
324 subWindowInfo.abilityName_ = "TestSubWithType";
325 subWindowInfo.bundleName_ = "TestSubWithType";
326 int32_t subWindowId = 35;
327 sptr<SceneSession> sceneSessionSubWindow = sptr<SceneSession>::MakeSptr(subWindowInfo, nullptr);
328 ASSERT_NE(sceneSessionSubWindow, nullptr);
329 sceneSessionSubWindow->persistentId_ = subWindowId;
330 sceneSessionSubWindow->isVisible_ = false;
331 uint32_t subFlags = static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_WATER_MARK);
332 sceneSessionSubWindow->property_->SetWindowFlags(subFlags);
333 int32_t subWindowPid = 55;
334 InitSceneSession(sceneSessionSubWindow, subWindowPid, subWindowId, WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
335 sceneSessionSubWindow->SetParentSession(nullptr);
336 std::map<int32_t, sptr<SceneSession>> retSceneSessionMap;
337 retSceneSessionMap.insert(std::make_pair(subWindowPid, sceneSessionSubWindow));
338 ssm_->sceneSessionMap_ = retSceneSessionMap;
339 std::map<int32_t, sptr<SceneSession>> sceneSessionMap =
340 Rosen::SceneSessionManager::GetInstance().GetSceneSessionMap();
341 int32_t windowInfoSize = sceneSessionMap.size();
342 ASSERT_EQ(windowInfoSize, 0);
343 }
344
345 /**
346 * @tc.name: GetWindowInfoWithoutParentWindowAndStateActive
347 * @tc.desc: windowInfo without parent window and state active
348 * @tc.type: FUNC
349 */
350 HWTEST_F(SceneSessionDirtyManagerTest2, GetWindowInfoWithoutParentWindowAndStateActive, Function | SmallTest | Level2)
351 {
352 SessionInfo subWindowInfo;
353 subWindowInfo.abilityName_ = "TestSubWithType";
354 subWindowInfo.bundleName_ = "TestSubWithType";
355 int32_t subWindowId = 36;
356 sptr<SceneSession> sceneSessionSubWindow = sptr<SceneSession>::MakeSptr(subWindowInfo, nullptr);
357 ASSERT_NE(sceneSessionSubWindow, nullptr);
358 sceneSessionSubWindow->persistentId_ = subWindowId;
359 sceneSessionSubWindow->isVisible_ = false;
360 uint32_t subFlags = static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_WATER_MARK);
361 sceneSessionSubWindow->property_->SetWindowFlags(subFlags);
362 int32_t subWindowPid = 56;
363 InitSceneSession(sceneSessionSubWindow, subWindowPid, subWindowId, WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
364 sceneSessionSubWindow->SetParentSession(nullptr);
365 sceneSessionSubWindow->SetSessionState(SessionState::STATE_ACTIVE);
366 std::map<int32_t, sptr<SceneSession>> retSceneSessionMap;
367 retSceneSessionMap.insert(std::make_pair(subWindowPid, sceneSessionSubWindow));
368 ssm_->sceneSessionMap_ = retSceneSessionMap;
369 std::map<int32_t, sptr<SceneSession>> sceneSessionMap =
370 Rosen::SceneSessionManager::GetInstance().GetSceneSessionMap();
371 int32_t windowInfoSize = sceneSessionMap.size();
372 ASSERT_EQ(windowInfoSize, 0);
373 }
374
375 /**
376 * @tc.name: GetWindowInfoWithNotSystemTouchable
377 * @tc.desc: windowInfo with systemtouchable is false
378 * @tc.type: FUNC
379 */
380 HWTEST_F(SceneSessionDirtyManagerTest2, GetWindowInfoWithNotSystemTouchable, Function | SmallTest | Level2)
381 {
382 SessionInfo mainWindowInfo;
383 mainWindowInfo.abilityName_ = "TestMainWithType";
384 mainWindowInfo.bundleName_ = "TestMainWithType";
385 int32_t mainWindowId = 37;
386 sptr<SceneSession> sceneSessionMainWindow = sptr<SceneSession>::MakeSptr(mainWindowInfo, nullptr);
387 ASSERT_NE(sceneSessionMainWindow, nullptr);
388 sceneSessionMainWindow->persistentId_ = mainWindowId;
389 sceneSessionMainWindow->isVisible_ = true;
390 uint32_t mainFlags = static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_WATER_MARK);
391 sceneSessionMainWindow->property_->SetWindowFlags(mainFlags);
392 bool isTouchable = false;
393 // set systemTouchable false;
394 sceneSessionMainWindow->SetSystemTouchable(isTouchable);
395 int32_t mainWindowPid = 57;
396 InitSceneSession(sceneSessionMainWindow, mainWindowPid, mainWindowId, WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
397 std::map<int32_t, sptr<SceneSession>> retSceneSessionMap;
398 retSceneSessionMap.insert(std::make_pair(mainWindowPid, sceneSessionMainWindow));
399 ssm_->sceneSessionMap_ = retSceneSessionMap;
400 MMI::WindowInfo windowInfo;
401 ScreenId screenId = 37;
402 ScreenSessionConfig config;
403 sptr<ScreenSession> screenSession =
404 sptr<ScreenSession>::MakeSptr(config, ScreenSessionReason::CREATE_SESSION_FOR_CLIENT);
405 ScreenSessionManagerClient::GetInstance().screenSessionMap_.insert(std::make_pair(screenId, screenSession));
406 manager_->UpdateWindowFlags(screenId, sceneSessionMainWindow, windowInfo);
407 bool windowFlagResult = false;
408 if (windowInfo.flags == 1) {
409 windowFlagResult = true;
410 }
411 ASSERT_EQ(windowFlagResult, true);
412 }
413
414 /**
415 * @tc.name: GetWindowInfoWithNotIsTouchEnable
416 * @tc.desc: windowInfo with isTouchenable is false
417 * @tc.type: FUNC
418 */
419 HWTEST_F(SceneSessionDirtyManagerTest2, GetWindowInfoWithNotIsTouchEnable, Function | SmallTest | Level2)
420 {
421 SessionInfo mainWindowInfo;
422 mainWindowInfo.abilityName_ = "TestMainWithType";
423 mainWindowInfo.bundleName_ = "TestMainWithType";
424 int32_t mainWindowId = 38;
425 sptr<SceneSession> sceneSessionMainWindow = sptr<SceneSession>::MakeSptr(mainWindowInfo, nullptr);
426 ASSERT_NE(sceneSessionMainWindow, nullptr);
427 sceneSessionMainWindow->persistentId_ = mainWindowId;
428 sceneSessionMainWindow->isVisible_ = true;
429 uint32_t mainFlags = static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_WATER_MARK);
430 sceneSessionMainWindow->property_->SetWindowFlags(mainFlags);
431 bool isTouchable = true;
432 sceneSessionMainWindow->SetSystemTouchable(isTouchable);
433 int32_t mainWindowPid = 58;
434 InitSceneSession(sceneSessionMainWindow, mainWindowPid, mainWindowId, WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
435 std::map<int32_t, sptr<SceneSession>> retSceneSessionMap;
436 retSceneSessionMap.insert(std::make_pair(mainWindowPid, sceneSessionMainWindow));
437 ssm_->sceneSessionMap_ = retSceneSessionMap;
438 MMI::WindowInfo windowInfo;
439 ScreenId screenId = 38;
440 ScreenSessionConfig config;
441 sptr<ScreenSession> screenSession =
442 sptr<ScreenSession>::MakeSptr(config, ScreenSessionReason::CREATE_SESSION_FOR_CLIENT);
443 // set screenSession touchenable_ true
444 screenSession->touchEnabled_.store(false);
445 ScreenSessionManagerClient::GetInstance().screenSessionMap_.clear();
446 ScreenSessionManagerClient::GetInstance().screenSessionMap_.insert(std::make_pair(screenId, screenSession));
447 manager_->UpdateWindowFlags(screenId, sceneSessionMainWindow, windowInfo);
448 bool windowFlagResult = false;
449 if (windowInfo.flags == MMI::WindowInfo::FLAG_BIT_UNTOUCHABLE) {
450 windowFlagResult = true;
451 }
452 ASSERT_EQ(windowFlagResult, true);
453 }
454
455 /**
456 * @tc.name: GetWindowInfoWithNotIsForceTouchEnable
457 * @tc.desc: windowInfo with isForeTouchenable is false
458 * @tc.type: FUNC
459 */
460 HWTEST_F(SceneSessionDirtyManagerTest2, GetWindowInfoWithNotIsForceTouchEnable, Function | SmallTest | Level2)
461 {
462 SessionInfo mainWindowInfo;
463 mainWindowInfo.abilityName_ = "TestMainWithType";
464 mainWindowInfo.bundleName_ = "TestMainWithType";
465 int32_t mainWindowId = 39;
466 sptr<SceneSession> sceneSessionMainWindow = sptr<SceneSession>::MakeSptr(mainWindowInfo, nullptr);
467 ASSERT_NE(sceneSessionMainWindow, nullptr);
468 sceneSessionMainWindow->persistentId_ = mainWindowId;
469 sceneSessionMainWindow->isVisible_ = true;
470 uint32_t mainFlags = static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_WATER_MARK);
471 sceneSessionMainWindow->property_->SetWindowFlags(mainFlags);
472 // set isForceTouchable false
473 bool isForceTouchable = false;
474 sceneSessionMainWindow->SetForceTouchable(isForceTouchable);
475 int32_t mainWindowPid = 59;
476 InitSceneSession(sceneSessionMainWindow, mainWindowPid, mainWindowId, WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
477 std::map<int32_t, sptr<SceneSession>> retSceneSessionMap;
478 retSceneSessionMap.insert(std::make_pair(mainWindowPid, sceneSessionMainWindow));
479 ssm_->sceneSessionMap_ = retSceneSessionMap;
480 MMI::WindowInfo windowInfo;
481 ScreenId screenId = 39;
482 ScreenSessionConfig config;
483 sptr<ScreenSession> screenSession =
484 sptr<ScreenSession>::MakeSptr(config, ScreenSessionReason::CREATE_SESSION_FOR_CLIENT);
485 screenSession->touchEnabled_.store(true);
486 ScreenSessionManagerClient::GetInstance().screenSessionMap_.insert(std::make_pair(screenId, screenSession));
487 manager_->UpdateWindowFlags(screenId, sceneSessionMainWindow, windowInfo);
488 bool windowFlagResult = false;
489 if (windowInfo.flags == 1) {
490 windowFlagResult = true;
491 }
492 ASSERT_EQ(windowFlagResult, true);
493 }
494
495 /**
496 * @tc.name: GetWindowInfoWithNotForegroundInteractiveStatus
497 * @tc.desc: windowInfo with foregroundInteractiveStatus_ is false
498 * @tc.type: FUNC
499 */
500 HWTEST_F(SceneSessionDirtyManagerTest2, GetWindowInfoWithNotForegroundInteractiveStatus, Function | SmallTest | Level2)
501 {
502 SessionInfo mainWindowInfo;
503 mainWindowInfo.abilityName_ = "TestMainWithType";
504 mainWindowInfo.bundleName_ = "TestMainWithType";
505 int32_t mainWindowId = 40;
506 sptr<SceneSession> sceneSessionMainWindow = sptr<SceneSession>::MakeSptr(mainWindowInfo, nullptr);
507 ASSERT_NE(sceneSessionMainWindow, nullptr);
508 sceneSessionMainWindow->persistentId_ = mainWindowId;
509 sceneSessionMainWindow->isVisible_ = true;
510 // set foregroundInterativeStatus_ false
511 sceneSessionMainWindow->foregroundInteractiveStatus_.store(false);
512 uint32_t mainFlags = static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_WATER_MARK);
513 sceneSessionMainWindow->property_->SetWindowFlags(mainFlags);
514 int32_t mainWindowPid = 60;
515 InitSceneSession(sceneSessionMainWindow, mainWindowPid, mainWindowId, WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
516 std::map<int32_t, sptr<SceneSession>> retSceneSessionMap;
517 retSceneSessionMap.insert(std::make_pair(mainWindowPid, sceneSessionMainWindow));
518 ssm_->sceneSessionMap_ = retSceneSessionMap;
519 MMI::WindowInfo windowInfo;
520 ScreenId screenId = 40;
521 ScreenSessionConfig config;
522 sptr<ScreenSession> screenSession =
523 sptr<ScreenSession>::MakeSptr(config, ScreenSessionReason::CREATE_SESSION_FOR_CLIENT);
524 ScreenSessionManagerClient::GetInstance().screenSessionMap_.insert(std::make_pair(screenId, screenSession));
525 manager_->UpdateWindowFlags(screenId, sceneSessionMainWindow, windowInfo);
526 bool windowFlagResult = false;
527 if (windowInfo.flags == 1) {
528 windowFlagResult = true;
529 }
530 ASSERT_EQ(windowFlagResult, true);
531 }
532
533 /**
534 * @tc.name: GetWindowInfoWithNotPropertyTouchable
535 * @tc.desc: windowInfo with property touchable false
536 * @tc.type: FUNC
537 */
538 HWTEST_F(SceneSessionDirtyManagerTest2, GetWindowInfoWithNotPropertyTouchable, Function | SmallTest | Level2)
539 {
540 SessionInfo mainWindowInfo;
541 mainWindowInfo.abilityName_ = "TestMainWithType";
542 mainWindowInfo.bundleName_ = "TestMainWithType";
543 int32_t mainWindowId = 41;
544 sptr<SceneSession> sceneSessionMainWindow = sptr<SceneSession>::MakeSptr(mainWindowInfo, nullptr);
545 ASSERT_NE(sceneSessionMainWindow, nullptr);
546 sceneSessionMainWindow->persistentId_ = mainWindowId;
547 sceneSessionMainWindow->foregroundInteractiveStatus_.store(false);
548 uint32_t mainFlags = static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_WATER_MARK);
549 sceneSessionMainWindow->property_->SetWindowFlags(mainFlags);
550 // set property_.touchEnable_ false
551 sceneSessionMainWindow->property_->touchable_ = false;
552 int32_t mainWindowPid = 61;
553 InitSceneSession(sceneSessionMainWindow, mainWindowPid, mainWindowId, WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
554 std::map<int32_t, sptr<SceneSession>> retSceneSessionMap;
555 retSceneSessionMap.insert(std::make_pair(mainWindowPid, sceneSessionMainWindow));
556 ssm_->sceneSessionMap_ = retSceneSessionMap;
557 MMI::WindowInfo windowInfo;
558 ScreenId screenId = 41;
559 ScreenSessionConfig config;
560 sptr<ScreenSession> screenSession =
561 sptr<ScreenSession>::MakeSptr(config, ScreenSessionReason::CREATE_SESSION_FOR_CLIENT);
562 ScreenSessionManagerClient::GetInstance().screenSessionMap_.insert(std::make_pair(screenId, screenSession));
563 manager_->UpdateWindowFlags(screenId, sceneSessionMainWindow, windowInfo);
564 bool windowFlagResult = false;
565 if (windowInfo.flags == 1) {
566 windowFlagResult = true;
567 }
568 ASSERT_EQ(windowFlagResult, true);
569 }
570
571 /**
572 * @tc.name: GetWindowInfoWithSameInfo
573 * @tc.desc: windowInfo with same displayInfos and windowInfos
574 * @tc.type: FUNC
575 */
576 HWTEST_F(SceneSessionDirtyManagerTest2, GetWindowInfoWithSameInfo, Function | SmallTest | Level2)
577 {
578 MMI::DisplayInfo lastDisplayedInfo;
579 MMI::WindowInfo lastWindowInfo;
580 InitSessionInfo(lastDisplayedInfo, lastWindowInfo);
581 int32_t focusedSession = 42;
582 sim_->focusedSessionId_ = focusedSession;
583 int32_t lastFocusedSession = 42;
584 sim_->lastFocusId_ = lastFocusedSession;
585 std::vector<MMI::DisplayInfo> lastDisplayInfos;
586 std::vector<MMI::WindowInfo> lastWindowInfoList;
587 lastDisplayInfos.emplace_back(lastDisplayedInfo);
588 lastWindowInfoList.emplace_back(lastWindowInfo);
589 sim_->lastDisplayInfos_ = lastDisplayInfos;
590 sim_->lastWindowInfoList_ = lastWindowInfoList;
591 MMI::DisplayInfo currDisplayedInfo;
592 MMI::WindowInfo currWindowInfo;
593 InitSessionInfo(currDisplayedInfo, currWindowInfo);
594 std::vector<MMI::DisplayInfo> currDisplayInfos;
595 std::vector<MMI::WindowInfo> currWindowInfoList;
596 currDisplayInfos.emplace_back(currDisplayedInfo);
597 currWindowInfoList.emplace_back(currWindowInfo);
598 auto focusGroup = ssm_->windowFocusController_->GetFocusGroup(DEFAULT_DISPLAY_ID);
599 focusGroup->SetFocusedSessionId(focusedSession);
600 bool checkNeedUpdateFlag = true;
601 // check the same information
602 checkNeedUpdateFlag = sim_->CheckNeedUpdate(currDisplayInfos, currWindowInfoList);
603 ASSERT_EQ(checkNeedUpdateFlag, false);
604 }
605
606 /**
607 * @tc.name: GetWindowInfoWithPidDiff
608 * @tc.desc: windowInfo with different pid
609 * @tc.type: FUNC
610 */
611 HWTEST_F(SceneSessionDirtyManagerTest2, GetWindowInfoWithPidDiff, Function | SmallTest | Level2)
612 {
613 MMI::DisplayInfo lastDisplayedInfo;
614 MMI::WindowInfo lastWindowInfo;
615 InitSessionInfo(lastDisplayedInfo, lastWindowInfo);
616 int32_t focusedSession = 43;
617 sim_->focusedSessionId_ = focusedSession;
618 int32_t lastFocusedSession = 43;
619 sim_->lastFocusId_ = lastFocusedSession;
620 std::vector<MMI::DisplayInfo> lastDisplayInfos;
621 std::vector<MMI::WindowInfo> lastWindowInfoList;
622 lastDisplayInfos.emplace_back(lastDisplayedInfo);
623 lastWindowInfoList.emplace_back(lastWindowInfo);
624 sim_->lastDisplayInfos_ = lastDisplayInfos;
625 sim_->lastWindowInfoList_ = lastWindowInfoList;
626 MMI::DisplayInfo currDisplayedInfo;
627 MMI::WindowInfo currWindowInfo;
628 InitSessionInfo(currDisplayedInfo, currWindowInfo);
629 // set different pid number
630 currWindowInfo.pid = 434;
631 std::vector<MMI::DisplayInfo> currDisplayInfos;
632 std::vector<MMI::WindowInfo> currWindowInfoList;
633 currDisplayInfos.emplace_back(currDisplayedInfo);
634 currWindowInfoList.emplace_back(currWindowInfo);
635 auto focusGroup = ssm_->windowFocusController_->GetFocusGroup(DEFAULT_DISPLAY_ID);
636 focusGroup->SetFocusedSessionId(focusedSession);
637 bool checkNeedUpdateFlag = false;
638 checkNeedUpdateFlag = sim_->CheckNeedUpdate(currDisplayInfos, currWindowInfoList);
639 ASSERT_EQ(checkNeedUpdateFlag, true);
640 }
641
642 /**
643 * @tc.name: GetWindowInfoWithAreaDiff
644 * @tc.desc: windowInfo with different area
645 * @tc.type: FUNC
646 */
647 HWTEST_F(SceneSessionDirtyManagerTest2, GetWindowInfoWithAreaDiff, Function | SmallTest | Level2)
648 {
649 MMI::DisplayInfo lastDisplayedInfo;
650 MMI::WindowInfo lastWindowInfo;
651 InitSessionInfo(lastDisplayedInfo, lastWindowInfo);
652 int32_t focusedSession = 44;
653 sim_->focusedSessionId_ = focusedSession;
654 int32_t lastFocusedSession = 44;
655 sim_->lastFocusId_ = lastFocusedSession;
656 std::vector<MMI::DisplayInfo> lastDisplayInfos;
657 std::vector<MMI::WindowInfo> lastWindowInfoList;
658 lastDisplayInfos.emplace_back(lastDisplayedInfo);
659 lastWindowInfoList.emplace_back(lastWindowInfo);
660 sim_->lastDisplayInfos_ = lastDisplayInfos;
661 sim_->lastWindowInfoList_ = lastWindowInfoList;
662 MMI::DisplayInfo currDisplayedInfo;
663 MMI::WindowInfo currWindowInfo;
664 InitSessionInfo(currDisplayedInfo, currWindowInfo);
665 // set different area number
666 currWindowInfo.area = {0, 0, 500, 600};
667 std::vector<MMI::DisplayInfo> currDisplayInfos;
668 std::vector<MMI::WindowInfo> currWindowInfoList;
669 currDisplayInfos.emplace_back(currDisplayedInfo);
670 currWindowInfoList.emplace_back(currWindowInfo);
671 auto focusGroup = ssm_->windowFocusController_->GetFocusGroup(DEFAULT_DISPLAY_ID);
672 focusGroup->SetFocusedSessionId(focusedSession);
673 bool checkNeedUpdateFlag = false;
674 checkNeedUpdateFlag = sim_->CheckNeedUpdate(currDisplayInfos, currWindowInfoList);
675 ASSERT_EQ(checkNeedUpdateFlag, true);
676 }
677
678 /**
679 * @tc.name: GetWindowInfoWithzOrderDiff
680 * @tc.desc: windowInfo with different zOrder
681 * @tc.type: FUNC
682 */
683 HWTEST_F(SceneSessionDirtyManagerTest2, GetWindowInfoWithzOrderDiff, Function | SmallTest | Level2)
684 {
685 MMI::DisplayInfo lastDisplayedInfo;
686 MMI::WindowInfo lastWindowInfo;
687 InitSessionInfo(lastDisplayedInfo, lastWindowInfo);
688 int32_t focusedSession = 45;
689 sim_->focusedSessionId_ = focusedSession;
690 int32_t lastFocusedSession = 45;
691 sim_->lastFocusId_ = lastFocusedSession;
692 std::vector<MMI::DisplayInfo> lastDisplayInfos;
693 std::vector<MMI::WindowInfo> lastWindowInfoList;
694 lastDisplayInfos.emplace_back(lastDisplayedInfo);
695 lastWindowInfoList.emplace_back(lastWindowInfo);
696 sim_->lastDisplayInfos_ = lastDisplayInfos;
697 sim_->lastWindowInfoList_ = lastWindowInfoList;
698 MMI::DisplayInfo currDisplayedInfo;
699 MMI::WindowInfo currWindowInfo;
700 InitSessionInfo(currDisplayedInfo, currWindowInfo);
701 // set different zOrder number
702 currWindowInfo.zOrder = 40.0;
703 std::vector<MMI::DisplayInfo> currDisplayInfos;
704 std::vector<MMI::WindowInfo> currWindowInfoList;
705 currDisplayInfos.emplace_back(currDisplayedInfo);
706 currWindowInfoList.emplace_back(currWindowInfo);
707 auto focusGroup = ssm_->windowFocusController_->GetFocusGroup(DEFAULT_DISPLAY_ID);
708 focusGroup->SetFocusedSessionId(focusedSession);
709 bool checkNeedUpdateFlag = false;
710 checkNeedUpdateFlag = sim_->CheckNeedUpdate(currDisplayInfos, currWindowInfoList);
711 ASSERT_EQ(checkNeedUpdateFlag, true);
712 }
713
714 } // namespace
715 } // namespace Rosen
716 } // namespace OHOS
717