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 <application_context.h>
17 #include <bundle_mgr_interface.h>
18 #include <bundlemgr/launcher_service.h>
19 #include <gtest/gtest.h>
20 #include <regex>
21
22 #include "context.h"
23 #include "interfaces/include/ws_common.h"
24 #include "iremote_object_mocker.h"
25 #include "mock/mock_session_stage.h"
26 #include "mock/mock_window_event_channel.h"
27 #include "session_info.h"
28 #include "session_manager.h"
29 #include "session_manager/include/scene_session_manager.h"
30 #include "session/host/include/main_session.h"
31 #include "session/host/include/pc_fold_screen_controller.h"
32 #include "session/host/include/scene_session.h"
33 #include "window_manager_agent.h"
34 #include "zidl/window_manager_agent_interface.h"
35
36 using namespace testing;
37 using namespace testing::ext;
38
39 namespace OHOS {
40 namespace Rosen {
41 namespace {
42 std::string g_logMsg;
MyLogCallback(const LogType type,const LogLevel level,const unsigned int domain,const char * tag,const char * msg)43 void MyLogCallback(const LogType type, const LogLevel level, const unsigned int domain, const char* tag,
44 const char* msg)
45 {
46 g_logMsg = msg;
47 }
48 }
49 class SceneSessionManagerTest4 : public testing::Test {
50 public:
51 static void SetUpTestCase();
52
53 static void TearDownTestCase();
54
55 void SetUp() override;
56
57 void TearDown() override;
58
59 static bool gestureNavigationEnabled_;
60
61 static ProcessGestureNavigationEnabledChangeFunc callbackFunc_;
62 static sptr<SceneSessionManager> ssm_;
63
64 private:
65 static constexpr uint32_t WAIT_SYNC_IN_NS = 200000;
66 };
67
68 sptr<SceneSessionManager> SceneSessionManagerTest4::ssm_ = nullptr;
69 bool SceneSessionManagerTest4::gestureNavigationEnabled_ = true;
70
71 ProcessGestureNavigationEnabledChangeFunc SceneSessionManagerTest4::callbackFunc_ =
__anonfc90b27a0202(bool enable, const std::string& bundleName, GestureBackType type) 72 [](bool enable, const std::string& bundleName, GestureBackType type) { gestureNavigationEnabled_ = enable; };
73
SetUpTestCase()74 void SceneSessionManagerTest4::SetUpTestCase()
75 {
76 ssm_ = &SceneSessionManager::GetInstance();
77 }
78
TearDownTestCase()79 void SceneSessionManagerTest4::TearDownTestCase()
80 {
81 ssm_ = nullptr;
82 }
83
SetUp()84 void SceneSessionManagerTest4::SetUp()
85 {
86 ssm_->sceneSessionMap_.clear();
87 }
88
TearDown()89 void SceneSessionManagerTest4::TearDown()
90 {
91 ssm_->sceneSessionMap_.clear();
92 usleep(WAIT_SYNC_IN_NS);
93 }
94
95 namespace {
96 /**
97 * @tc.name: UpdateSceneSessionWant01
98 * @tc.desc: SceneSesionManager test UpdateSceneSessionWant
99 * @tc.type: FUNC
100 */
101 HWTEST_F(SceneSessionManagerTest4, UpdateSceneSessionWant01, TestSize.Level1)
102 {
103 SessionInfo info;
104 info.persistentId_ = 0;
105 ssm_->UpdateSceneSessionWant(info);
106 ASSERT_NE(ssm_, nullptr);
107 }
108
109 /**
110 * @tc.name: UpdateSceneSessionWant02
111 * @tc.desc: SceneSesionManager test UpdateSceneSessionWant
112 * @tc.type: FUNC
113 */
114 HWTEST_F(SceneSessionManagerTest4, UpdateSceneSessionWant02, TestSize.Level1)
115 {
116 SessionInfo info;
117 info.persistentId_ = 1;
118 ssm_->UpdateSceneSessionWant(info);
119 ASSERT_NE(ssm_, nullptr);
120 }
121
122 /**
123 * @tc.name: UpdateSceneSessionWant03
124 * @tc.desc: SceneSesionManager test UpdateSceneSessionWant
125 * @tc.type: FUNC
126 */
127 HWTEST_F(SceneSessionManagerTest4, UpdateSceneSessionWant03, TestSize.Level1)
128 {
129 SessionInfo info;
130 info.persistentId_ = 1;
131 auto sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
132 ASSERT_NE(sceneSession, nullptr);
133 ssm_->sceneSessionMap_.insert({ 1, sceneSession });
134 ssm_->UpdateSceneSessionWant(info);
135 ASSERT_NE(ssm_, nullptr);
136 }
137
138 /**
139 * @tc.name: UpdateSceneSessionWant04
140 * @tc.desc: SceneSesionManager test UpdateSceneSessionWant
141 * @tc.type: FUNC
142 */
143 HWTEST_F(SceneSessionManagerTest4, UpdateSceneSessionWant04, TestSize.Level1)
144 {
145 SessionInfo info;
146 info.persistentId_ = 1;
147 std::shared_ptr<AAFwk::Want> want = std::make_shared<AAFwk::Want>();
148 info.want = want;
149 auto sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
150 ASSERT_NE(sceneSession, nullptr);
151 ssm_->sceneSessionMap_.insert({ 1, sceneSession });
152 ssm_->UpdateSceneSessionWant(info);
153 ASSERT_NE(ssm_, nullptr);
154 }
155
156 /**
157 * @tc.name: UpdateSceneSessionWant05
158 * @tc.desc: SceneSesionManager test UpdateSceneSessionWant
159 * @tc.type: FUNC
160 */
161 HWTEST_F(SceneSessionManagerTest4, UpdateSceneSessionWant05, TestSize.Level1)
162 {
163 SessionInfo info;
164 info.persistentId_ = 1;
165 std::shared_ptr<AAFwk::Want> want = std::make_shared<AAFwk::Want>();
166 info.want = want;
167 auto sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
168 ASSERT_NE(sceneSession, nullptr);
169 int32_t collaboratorType = CollaboratorType::RESERVE_TYPE;
170 sceneSession->SetCollaboratorType(collaboratorType);
171 ssm_->sceneSessionMap_.insert({ 1, sceneSession });
172 ssm_->UpdateSceneSessionWant(info);
173 ASSERT_NE(ssm_, nullptr);
174 }
175
176 /**
177 * @tc.name: UpdateSceneSessionWant06
178 * @tc.desc: SceneSesionManager test UpdateSceneSessionWant
179 * @tc.type: FUNC
180 */
181 HWTEST_F(SceneSessionManagerTest4, UpdateSceneSessionWant06, TestSize.Level1)
182 {
183 SessionInfo info;
184 info.persistentId_ = 1;
185 std::shared_ptr<AAFwk::Want> want = std::make_shared<AAFwk::Want>();
186 info.want = want;
187 auto sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
188 ASSERT_NE(sceneSession, nullptr);
189 int32_t collaboratorType = -1;
190 sceneSession->SetCollaboratorType(collaboratorType);
191 ssm_->sceneSessionMap_.insert({ 1, sceneSession });
192 ssm_->UpdateSceneSessionWant(info);
193 ASSERT_NE(ssm_, nullptr);
194 }
195
196 /**
197 * @tc.name: GetSceneSessionByIdentityInfo01
198 * @tc.desc: SceneSesionManager test GetSceneSessionByIdentityInfo
199 * @tc.type: FUNC
200 */
201 HWTEST_F(SceneSessionManagerTest4, GetSceneSessionByIdentityInfo01, TestSize.Level1)
202 {
203 std::string abilityName = "test1";
204 std::string bundleName = "test2";
205 std::string moduleName = "test3";
206 int32_t appIndex = 10;
207 SessionInfo info;
208 info.abilityName_ = abilityName;
209 info.bundleName_ = bundleName;
210 info.moduleName_ = moduleName;
211 info.appIndex_ = appIndex;
212 info.persistentId_ = 1;
213 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
214 ASSERT_NE(sceneSession, nullptr);
215 ssm_->sceneSessionMap_.insert({ 1, sceneSession });
216 SessionIdentityInfo identityInfo = { bundleName, moduleName, abilityName, appIndex };
217 ASSERT_NE(ssm_->GetSceneSessionByIdentityInfo(identityInfo), nullptr);
218 }
219
220 /**
221 * @tc.name: DestroyAndDisconnectSpecificSession01
222 * @tc.desc: SceneSesionManager test DestroyAndDisconnectSpecificSession
223 * @tc.type: FUNC
224 */
225 HWTEST_F(SceneSessionManagerTest4, DestroyAndDisconnectSpecificSession01, TestSize.Level1)
226 {
227 SessionInfo info;
228 info.abilityName_ = "DestroyAndDisconnectSpecificSession";
229 info.bundleName_ = "DestroyAndDisconnectSpecificSession";
230 info.persistentId_ = 1;
231 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
232 ASSERT_NE(sceneSession, nullptr);
233 ssm_->sceneSessionMap_.insert({ 1, sceneSession });
234 ASSERT_NE(ssm_->DestroyAndDisconnectSpecificSession(1), WSError::WS_ERROR_NULLPTR);
235 }
236
237 /**
238 * @tc.name: NotifyEnterRecentTask02
239 * @tc.desc: NotifyEnterRecentTask
240 * @tc.type: FUNC
241 */
242 HWTEST_F(SceneSessionManagerTest4, NotifyEnterRecentTask02, TestSize.Level1)
243 {
244 ASSERT_NE(nullptr, ssm_);
245 EXPECT_EQ(ssm_->NotifyEnterRecentTask(false), WSError::WS_OK);
246 }
247
248 /**
249 * @tc.name: GetWindowStatus
250 * @tc.desc: GetWindowStatus
251 * @tc.type: FUNC
252 */
253 HWTEST_F(SceneSessionManagerTest4, GetWindowStatus, TestSize.Level1)
254 {
255 ASSERT_NE(nullptr, ssm_);
256 WindowMode mode = WindowMode::WINDOW_MODE_FLOATING;
257 SessionState sessionState = SessionState::STATE_FOREGROUND;
258 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
259 ASSERT_NE(property, nullptr);
260 auto result = ssm_->GetWindowStatus(mode, sessionState, nullptr);
261 EXPECT_EQ(result, WindowStatus::WINDOW_STATUS_UNDEFINED);
262 }
263
264 /**
265 * @tc.name: GetWindowStatus02
266 * @tc.desc: GetWindowStatus
267 * @tc.type: FUNC
268 */
269 HWTEST_F(SceneSessionManagerTest4, GetWindowStatus02, TestSize.Level1)
270 {
271 ASSERT_NE(nullptr, ssm_);
272 WindowMode mode = WindowMode::WINDOW_MODE_FLOATING;
273 SessionState sessionState = SessionState::STATE_FOREGROUND;
274 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
275 ASSERT_NE(property, nullptr);
276 auto result = ssm_->GetWindowStatus(mode, sessionState, nullptr);
277 property->SetMaximizeMode(MaximizeMode::MODE_AVOID_SYSTEM_BAR);
278 result = ssm_->GetWindowStatus(mode, sessionState, property);
279 EXPECT_EQ(result, WindowStatus::WINDOW_STATUS_MAXIMIZE);
280 }
281
282 /**
283 * @tc.name: GetWindowStatus03
284 * @tc.desc: GetWindowStatus
285 * @tc.type: FUNC
286 */
287 HWTEST_F(SceneSessionManagerTest4, GetWindowStatus03, TestSize.Level1)
288 {
289 ASSERT_NE(nullptr, ssm_);
290 WindowMode mode = WindowMode::WINDOW_MODE_FLOATING;
291 SessionState sessionState = SessionState::STATE_FOREGROUND;
292 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
293 ASSERT_NE(property, nullptr);
294 auto result = ssm_->GetWindowStatus(mode, sessionState, nullptr);
295 property->SetMaximizeMode(MaximizeMode::MODE_FULL_FILL);
296 result = ssm_->GetWindowStatus(mode, sessionState, property);
297 EXPECT_EQ(result, WindowStatus::WINDOW_STATUS_FLOATING);
298 }
299
300 /**
301 * @tc.name: GetWindowStatus04
302 * @tc.desc: GetWindowStatus
303 * @tc.type: FUNC
304 */
305 HWTEST_F(SceneSessionManagerTest4, GetWindowStatus04, TestSize.Level1)
306 {
307 ASSERT_NE(nullptr, ssm_);
308 WindowMode mode = WindowMode::WINDOW_MODE_FLOATING;
309 SessionState sessionState = SessionState::STATE_FOREGROUND;
310 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
311 ASSERT_NE(property, nullptr);
312 mode = WindowMode::WINDOW_MODE_SPLIT_PRIMARY;
313 auto result = ssm_->GetWindowStatus(mode, sessionState, property);
314 EXPECT_EQ(result, WindowStatus::WINDOW_STATUS_SPLITSCREEN);
315 }
316
317 /**
318 * @tc.name: UpdateDisplayRegion
319 * @tc.desc: UpdateDisplayRegion
320 * @tc.type: FUNC
321 */
322 HWTEST_F(SceneSessionManagerTest4, UpdateDisplayRegion, TestSize.Level1)
323 {
324 ASSERT_NE(nullptr, ssm_);
325 ssm_->UpdateDisplayRegion(nullptr);
326 sptr<DisplayInfo> displayInfo = sptr<DisplayInfo>::MakeSptr();
327 ASSERT_NE(displayInfo, nullptr);
328
329 constexpr DisplayId displayId = 0;
330 constexpr int32_t width = 100;
331 displayInfo->SetDisplayId(displayId);
332 displayInfo->SetWidth(width);
333 ssm_->UpdateDisplayRegion(displayInfo);
334
335 constexpr int32_t height = 200;
336 displayInfo->SetWidth(width);
337 displayInfo->SetHeight(height);
338 ssm_->UpdateDisplayRegion(displayInfo);
339
340 displayInfo->SetHeight(height);
341 PcFoldScreenManager::GetInstance().SetDisplayInfo(displayId, SuperFoldStatus::HALF_FOLDED);
342 PcFoldScreenManager::GetInstance().SetDisplayRects(WSRect::EMPTY_RECT, { 0, 0, width, height }, WSRect::EMPTY_RECT);
343 ssm_->UpdateDisplayRegion(displayInfo);
344 ASSERT_NE(ssm_->displayRegionMap_.count(displayId), 0);
345 auto region = ssm_->displayRegionMap_[displayId];
346 ASSERT_NE(region, nullptr);
347 const SkIRect& rect = region->getBounds();
348 EXPECT_EQ(rect.fLeft, 0);
349 EXPECT_EQ(rect.fTop, 0);
350 EXPECT_EQ(rect.fRight, width);
351 EXPECT_EQ(rect.fBottom, height);
352 }
353
354 /**
355 * @tc.name: GetDisplayRegion
356 * @tc.desc: GetDisplayRegion
357 * @tc.type: FUNC
358 */
359 HWTEST_F(SceneSessionManagerTest4, GetDisplayRegion, TestSize.Level1)
360 {
361 ASSERT_NE(nullptr, ssm_);
362 constexpr DisplayId displayId = 0;
363 auto region = ssm_->GetDisplayRegion(displayId);
364 EXPECT_NE(region, nullptr);
365
366 constexpr int32_t left = 0;
367 constexpr int32_t top = 0;
368 constexpr int32_t right = 100;
369 constexpr int32_t bottom = 200;
370 SkIRect rect{ .fLeft = left, .fTop = top, .fRight = right, .fBottom = bottom };
371 ssm_->displayRegionMap_[displayId] = std::make_shared<SkRegion>(rect);
372 auto region1 = ssm_->GetDisplayRegion(displayId);
373 ASSERT_NE(region1, nullptr);
374 const SkIRect& rect1 = region1->getBounds();
375 EXPECT_EQ(rect1.fLeft, 0);
376 EXPECT_EQ(rect1.fTop, 0);
377 EXPECT_EQ(rect1.fRight, right);
378 EXPECT_EQ(rect1.fBottom, bottom);
379 }
380
381 /**
382 * @tc.name: GetCustomDecorHeight
383 * @tc.desc: GetCustomDecorHeight
384 * @tc.type: FUNC
385 */
386 HWTEST_F(SceneSessionManagerTest4, GetCustomDecorHeight, TestSize.Level1)
387 {
388 ASSERT_NE(nullptr, ssm_);
389 SessionInfo info;
390 info.abilityName_ = "SetBrightness";
391 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
392 ASSERT_NE(sceneSession, nullptr);
393 sceneSession->SetCustomDecorHeight(50);
394 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession));
395 ssm_->sceneSessionMap_.insert(std::make_pair(2, nullptr));
396 EXPECT_EQ(0, ssm_->GetCustomDecorHeight(2));
397 EXPECT_EQ(50, ssm_->GetCustomDecorHeight(1));
398 }
399
400 /**
401 * @tc.name: IsVectorSame
402 * @tc.desc: IsVectorSame
403 * @tc.type: FUNC
404 */
405 HWTEST_F(SceneSessionManagerTest4, IsVectorSame, TestSize.Level1)
406 {
407 ASSERT_NE(nullptr, ssm_);
408 std::vector<VisibleWindowNumInfo> lastInfo;
409 std::vector<VisibleWindowNumInfo> currentInfo;
410 VisibleWindowNumInfo num;
411 lastInfo.push_back(num);
412 EXPECT_EQ(false, ssm_->IsVectorSame(lastInfo, currentInfo));
413 lastInfo.clear();
414 }
415
416 /**
417 * @tc.name: IsVectorSame01
418 * @tc.desc: IsVectorSame
419 * @tc.type: FUNC
420 */
421 HWTEST_F(SceneSessionManagerTest4, IsVectorSame01, TestSize.Level1)
422 {
423 ASSERT_NE(nullptr, ssm_);
424 std::vector<VisibleWindowNumInfo> lastInfo;
425 std::vector<VisibleWindowNumInfo> currentInfo;
426 lastInfo.reserve(2);
427 VisibleWindowNumInfo oneNum;
428 oneNum.displayId = 0;
429 oneNum.visibleWindowNum = 3;
430 lastInfo.push_back(oneNum);
431 currentInfo.push_back(oneNum);
432 EXPECT_EQ(true, ssm_->IsVectorSame(lastInfo, currentInfo));
433 }
434
435 /**
436 * @tc.name: IsVectorSame03
437 * @tc.desc: IsVectorSame
438 * @tc.type: FUNC
439 */
440 HWTEST_F(SceneSessionManagerTest4, IsVectorSame03, TestSize.Level1)
441 {
442 ASSERT_NE(nullptr, ssm_);
443 std::vector<VisibleWindowNumInfo> lastInfo;
444 std::vector<VisibleWindowNumInfo> currentInfo;
445 lastInfo.clear();
446 currentInfo.clear();
447 VisibleWindowNumInfo twoNum;
448 twoNum.displayId = 0;
449 twoNum.visibleWindowNum = 2;
450 currentInfo.push_back(twoNum);
451 EXPECT_EQ(false, ssm_->IsVectorSame(lastInfo, currentInfo));
452 }
453
454 /**
455 * @tc.name: IsVectorSame04
456 * @tc.desc: IsVectorSame
457 * @tc.type: FUNC
458 */
459 HWTEST_F(SceneSessionManagerTest4, IsVectorSame04, TestSize.Level1)
460 {
461 ASSERT_NE(nullptr, ssm_);
462 std::vector<VisibleWindowNumInfo> lastInfo;
463 std::vector<VisibleWindowNumInfo> currentInfo;
464 VisibleWindowNumInfo twoNum;
465 currentInfo.clear();
466 twoNum.displayId = 1;
467 twoNum.visibleWindowNum = 3;
468 currentInfo.push_back(twoNum);
469 EXPECT_EQ(false, ssm_->IsVectorSame(lastInfo, currentInfo));
470 }
471
472 /**
473 * @tc.name: ReportWindowProfileInfos
474 * @tc.desc: ReportWindowProfileInfos
475 * @tc.type: FUNC
476 */
477 HWTEST_F(SceneSessionManagerTest4, ReportWindowProfileInfos, TestSize.Level1)
478 {
479 ASSERT_NE(nullptr, ssm_);
480 SessionInfo info;
481 info.abilityName_ = "SetBrightness";
482 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
483 ASSERT_NE(sceneSession, nullptr);
484 sceneSession->sessionInfo_.isSystem_ = false;
485 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession));
486 ssm_->ReportWindowProfileInfos();
487 auto focusGroup = ssm_->windowFocusController_->GetFocusGroup(DEFAULT_DISPLAY_ID);
488 focusGroup->SetFocusedSessionId(123);
489 ssm_->ReportWindowProfileInfos();
490 EXPECT_EQ(WSError::WS_ERROR_INVALID_SESSION, ssm_->HandleSecureSessionShouldHide(nullptr));
491 }
492
493 /**
494 * @tc.name: ReportWindowProfileInfos02
495 * @tc.desc: ReportWindowProfileInfos
496 * @tc.type: FUNC
497 */
498 HWTEST_F(SceneSessionManagerTest4, ReportWindowProfileInfos02, TestSize.Level1)
499 {
500 ASSERT_NE(nullptr, ssm_);
501 SessionInfo info;
502 info.abilityName_ = "SetBrightness";
503 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
504 ASSERT_NE(sceneSession, nullptr);
505 sceneSession->sessionInfo_.isSystem_ = false;
506 sptr<Session> session = sptr<Session>::MakeSptr(info);
507 ASSERT_NE(session, nullptr);
508 ASSERT_NE(sceneSession->property_, nullptr);
509 sceneSession->property_->type_ = WindowType::WINDOW_TYPE_MEDIA;
510 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession));
511 ssm_->ReportWindowProfileInfos();
512 EXPECT_EQ(WSError::WS_ERROR_INVALID_SESSION, ssm_->HandleSecureSessionShouldHide(nullptr));
513 }
514
515 /**
516 * @tc.name: ReportWindowProfileInfos03
517 * @tc.desc: ReportWindowProfileInfos
518 * @tc.type: FUNC
519 */
520 HWTEST_F(SceneSessionManagerTest4, ReportWindowProfileInfos03, TestSize.Level1)
521 {
522 ASSERT_NE(nullptr, ssm_);
523 SessionInfo info;
524 info.abilityName_ = "SetBrightness";
525 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
526 ASSERT_NE(sceneSession, nullptr);
527 sceneSession->sessionInfo_.isSystem_ = true;
528 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession));
529 ssm_->ReportWindowProfileInfos();
530 EXPECT_EQ(WSError::WS_ERROR_INVALID_SESSION, ssm_->HandleSecureSessionShouldHide(nullptr));
531 }
532
533 /**
534 * @tc.name: ReportWindowProfileInfos04
535 * @tc.desc: ReportWindowProfileInfos
536 * @tc.type: FUNC
537 */
538 HWTEST_F(SceneSessionManagerTest4, ReportWindowProfileInfos04, TestSize.Level1)
539 {
540 ASSERT_NE(nullptr, ssm_);
541 ssm_->sceneSessionMap_.insert(std::make_pair(1, nullptr));
542 ssm_->ReportWindowProfileInfos();
543 EXPECT_EQ(WSError::WS_ERROR_INVALID_SESSION, ssm_->HandleSecureSessionShouldHide(nullptr));
544 }
545
546 /**
547 * @tc.name: CacVisibleWindowNum
548 * @tc.desc: CacVisibleWindowNum
549 * @tc.type: FUNC
550 */
551 HWTEST_F(SceneSessionManagerTest4, CacVisibleWindowNum, TestSize.Level1)
552 {
553 ASSERT_NE(nullptr, ssm_);
554 SessionInfo info;
555 info.abilityName_ = "SetBrightness";
556 sptr<SceneSession> sceneSession01 = sptr<SceneSession>::MakeSptr(info, nullptr);
557 sptr<SceneSession> sceneSession02 = sptr<SceneSession>::MakeSptr(info, nullptr);
558 sptr<SceneSession> sceneSession03 = sptr<SceneSession>::MakeSptr(info, nullptr);
559 sptr<SceneSession> sceneSession04 = sptr<SceneSession>::MakeSptr(info, nullptr);
560 ASSERT_NE(sceneSession01, nullptr);
561 ASSERT_NE(sceneSession02, nullptr);
562 ASSERT_NE(sceneSession03, nullptr);
563 ASSERT_NE(sceneSession04, nullptr);
564 ASSERT_NE(sceneSession01->property_, nullptr);
565 sceneSession01->property_->type_ = WindowType::WINDOW_TYPE_WALLPAPER;
566 sceneSession01->SetRSVisible(true);
567 sceneSession02->state_ = SessionState::STATE_BACKGROUND;
568 ASSERT_NE(sceneSession03->property_, nullptr);
569 sceneSession03->property_->type_ = WindowType::APP_MAIN_WINDOW_END;
570 ASSERT_NE(sceneSession04->property_, nullptr);
571 sceneSession04->property_->type_ = WindowType::WINDOW_TYPE_WALLPAPER;
572 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession01));
573 ssm_->sceneSessionMap_.insert(std::make_pair(2, sceneSession02));
574 ssm_->sceneSessionMap_.insert(std::make_pair(3, sceneSession03));
575 ssm_->sceneSessionMap_.insert(std::make_pair(4, sceneSession04));
576 ssm_->sceneSessionMap_.insert(std::make_pair(5, nullptr));
577
578 ssm_->CacVisibleWindowNum();
579 EXPECT_EQ(WSError::WS_ERROR_INVALID_SESSION, ssm_->HandleSecureSessionShouldHide(nullptr));
580 }
581
582 /**
583 * @tc.name: GetAppMainSceneSession
584 * @tc.desc: GetAppMainSceneSession
585 * @tc.type: FUNC
586 */
587 HWTEST_F(SceneSessionManagerTest4, GetAppMainSceneSession, TestSize.Level1)
588 {
589 ASSERT_NE(nullptr, ssm_);
590 SessionInfo info;
591 info.abilityName_ = "SetBrightness";
592 sptr<SceneSession> sceneSession;
593 sptr<SceneSession> sceneSession01 = sptr<SceneSession>::MakeSptr(info, nullptr);
594 sptr<SceneSession> sceneSession02 = sptr<SceneSession>::MakeSptr(info, nullptr);
595 ASSERT_NE(sceneSession01, nullptr);
596 ASSERT_NE(sceneSession02, nullptr);
597 ssm_->sceneSessionMap_.insert(std::make_pair(0, sceneSession));
598 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession01));
599 ssm_->sceneSessionMap_.insert(std::make_pair(2, sceneSession02));
600 EXPECT_EQ(ssm_->GetAppMainSceneSession(0, sceneSession), WSError::WS_ERROR_INVALID_SESSION);
601
602 EXPECT_EQ(ssm_->GetAppMainSceneSession(1, sceneSession01), WSError::WS_OK);
603
604 ASSERT_NE(sceneSession01->property_, nullptr);
605 sceneSession01->property_->type_ = WindowType::WINDOW_TYPE_MEDIA;
606 EXPECT_EQ(ssm_->GetAppMainSceneSession(1, sceneSession01), WSError::WS_ERROR_INVALID_CALLING);
607
608 sceneSession01->property_->type_ = WindowType::WINDOW_TYPE_APP_SUB_WINDOW;
609 sceneSession01->property_->SetParentPersistentId(2);
610 EXPECT_EQ(ssm_->GetAppMainSceneSession(1, sceneSession01), WSError::WS_OK);
611 }
612
613 /**
614 * @tc.name: GetImmersiveState01
615 * @tc.desc: GetImmersiveState
616 * @tc.type: FUNC
617 */
618 HWTEST_F(SceneSessionManagerTest4, GetImmersiveState01, TestSize.Level1)
619 {
620 ASSERT_NE(nullptr, ssm_);
621 ssm_->systemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
622
623 SessionInfo info;
624 info.abilityName_ = "GetImmersiveState01";
625 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
626 ASSERT_NE(sceneSession, nullptr);
627 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession));
628
629 sceneSession->property_->type_ = WindowType::APP_MAIN_WINDOW_BASE;
630 sceneSession->state_ = SessionState::STATE_ACTIVE;
631 sceneSession->state_ = SessionState::STATE_FOREGROUND;
632 sceneSession->property_->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
633 EXPECT_EQ(false, ssm_->GetImmersiveState(0u));
634 sceneSession->SetIsLayoutFullScreen(true);
635 EXPECT_EQ(true, ssm_->GetImmersiveState(0u));
636 }
637
638 /**
639 * @tc.name: GetImmersiveState02
640 * @tc.desc: GetImmersiveState
641 * @tc.type: FUNC
642 */
643 HWTEST_F(SceneSessionManagerTest4, GetImmersiveState02, TestSize.Level1)
644 {
645 ASSERT_NE(nullptr, ssm_);
646 ssm_->systemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
647
648 SessionInfo info;
649 info.abilityName_ = "GetImmersiveState02";
650 sptr<SceneSession> sceneSession01;
651 sptr<SceneSession> sceneSession02 = sptr<SceneSession>::MakeSptr(info, nullptr);
652 ASSERT_EQ(sceneSession01, nullptr);
653 ASSERT_NE(sceneSession02, nullptr);
654 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession01));
655 ssm_->sceneSessionMap_.insert(std::make_pair(2, sceneSession02));
656
657 EXPECT_EQ(false, ssm_->GetImmersiveState(0u));
658 sceneSession02->property_->type_ = WindowType::APP_MAIN_WINDOW_END;
659 EXPECT_EQ(false, ssm_->GetImmersiveState(0u));
660 sceneSession02->property_->type_ = WindowType::APP_MAIN_WINDOW_BASE;
661 EXPECT_EQ(false, ssm_->GetImmersiveState(0u));
662 sceneSession02->state_ = SessionState::STATE_ACTIVE;
663 EXPECT_EQ(false, ssm_->GetImmersiveState(0u));
664 sceneSession02->state_ = SessionState::STATE_FOREGROUND;
665 EXPECT_EQ(false, ssm_->GetImmersiveState(0u));
666 sceneSession02->property_->SetWindowMode(WindowMode::WINDOW_MODE_UNDEFINED);
667 EXPECT_EQ(false, ssm_->GetImmersiveState(0u));
668 sceneSession02->property_->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
669 sceneSession02->property_->sysBarPropMap_[WindowType::WINDOW_TYPE_STATUS_BAR].enable_ = false;
670 EXPECT_EQ(true, ssm_->GetImmersiveState(0u));
671 sceneSession02->property_->sysBarPropMap_[WindowType::WINDOW_TYPE_STATUS_BAR].enable_ = true;
672 EXPECT_EQ(false, ssm_->GetImmersiveState(0u));
673 }
674
675 /**
676 * @tc.name: UpdateSessionDisplayId
677 * @tc.desc: UpdateSessionDisplayId
678 * @tc.type: FUNC
679 */
680 HWTEST_F(SceneSessionManagerTest4, UpdateSessionDisplayId, TestSize.Level1)
681 {
682 ASSERT_NE(nullptr, ssm_);
683 auto result = ssm_->UpdateSessionDisplayId(0, 0);
684 EXPECT_EQ(result, WSError::WS_ERROR_INVALID_WINDOW);
685
686 SessionInfo info;
687 info.abilityName_ = "SetBrightness";
688 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
689 ASSERT_NE(sceneSession, nullptr);
690 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession));
691 sceneSession->sessionInfo_.screenId_ = 6;
692 sceneSession->SetPropertyDirtyFlags(0);
693 result = ssm_->UpdateSessionDisplayId(1, 2);
694 EXPECT_EQ(result, WSError::WS_OK);
695 EXPECT_EQ(sceneSession->GetPropertyDirtyFlags(), static_cast<uint32_t>(SessionPropertyFlag::DISPLAY_ID));
696 }
697
698 /**
699 * @tc.name: UpdateSessionWindowVisibilityListener02
700 * @tc.desc: UpdateSessionWindowVisibilityListener
701 * @tc.type: FUNC
702 */
703 HWTEST_F(SceneSessionManagerTest4, UpdateSessionWindowVisibilityListener02, TestSize.Level1)
704 {
705 ASSERT_NE(nullptr, ssm_);
706 SessionInfo info;
707 info.abilityName_ = "SetBrightness";
708 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
709 ASSERT_NE(sceneSession, nullptr);
710 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession));
711 int32_t persistentId = 1;
712 auto result = ssm_->UpdateSessionWindowVisibilityListener(persistentId, true);
713 EXPECT_EQ(result, WSError::WS_ERROR_INVALID_PERMISSION);
714 }
715
716 /**
717 * @tc.name: NotifyScreenshotEvent
718 * @tc.desc: test WS_OK
719 * @tc.type: FUNC
720 */
721 HWTEST_F(SceneSessionManagerTest4, NotifyScreenshotEvent, TestSize.Level1)
722 {
723 g_logMsg.clear();
724 LOG_SetCallback(MyLogCallback);
725 ASSERT_NE(nullptr, ssm_);
726 auto ret = ssm_->NotifyScreenshotEvent(ScreenshotEventType::SCROLL_SHOT_START);
727 EXPECT_EQ(ret, WMError::WM_OK);
728
729 ssm_->screenshotAppEventListenerSessionSet_.insert(1);
730 ret = ssm_->NotifyScreenshotEvent(ScreenshotEventType::SCROLL_SHOT_START);
731 EXPECT_EQ(ret, WMError::WM_OK);
732
733 SessionInfo info;
734 info.abilityName_ = "NotifyScreenshotEvent";
735 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
736 ASSERT_NE(sceneSession, nullptr);
737 sceneSession->property_->SetPersistentId(1);
738 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession));
739
740 sceneSession->SetSessionState(SessionState::STATE_FOREGROUND);
741 ret = ssm_->NotifyScreenshotEvent(ScreenshotEventType::SCROLL_SHOT_START);
742 EXPECT_EQ(ret, WMError::WM_OK);
743
744 sceneSession->SetSessionState(SessionState::STATE_ACTIVE);
745 ret = ssm_->NotifyScreenshotEvent(ScreenshotEventType::SCROLL_SHOT_START);
746 EXPECT_EQ(ret, WMError::WM_OK);
747
748 sceneSession->SetSessionState(SessionState::STATE_BACKGROUND);
749 ret = ssm_->NotifyScreenshotEvent(ScreenshotEventType::SCROLL_SHOT_START);
750 EXPECT_EQ(ret, WMError::WM_OK);
751 }
752
753 /**
754 * @tc.name: UpdateSessionScreenshotAppEventListener01
755 * @tc.desc: test WM_ERROR_NULLPTR
756 * @tc.type: FUNC
757 */
758 HWTEST_F(SceneSessionManagerTest4, UpdateSessionScreenshotAppEventListener01, TestSize.Level1)
759 {
760 int32_t persistentId = 10086;
761 bool haveListener = true;
762 WMError ret = ssm_->UpdateSessionScreenshotAppEventListener(persistentId, haveListener);
763 EXPECT_EQ(ret, WMError::WM_ERROR_NULLPTR);
764 }
765
766 /**
767 * @tc.name: UpdateSessionScreenshotAppEventListener02
768 * @tc.desc: test WS_OK
769 * @tc.type: FUNC
770 */
771 HWTEST_F(SceneSessionManagerTest4, UpdateSessionScreenshotAppEventListener02, TestSize.Level1)
772 {
773 ASSERT_NE(nullptr, ssm_);
774 SessionInfo info;
775 info.abilityName_ = "UpdateSessionScreenshotAppEventListener";
776 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
777 ASSERT_NE(sceneSession, nullptr);
778 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession));
779 int32_t persistentId = 1;
780 auto ret = ssm_->UpdateSessionScreenshotAppEventListener(persistentId, true);
781 EXPECT_EQ(ret, WMError::WM_OK);
782 ret = ssm_->UpdateSessionScreenshotAppEventListener(persistentId, false);
783 EXPECT_EQ(ret, WMError::WM_OK);
784 }
785
786 /**
787 * @tc.name: UpdateDarkColorModeToRS
788 * @tc.desc: UpdateDarkColorModeToRS
789 * @tc.type: FUNC
790 * @tc.require: issueIB1N43
791 */
792 HWTEST_F(SceneSessionManagerTest4, UpdateDarkColorModeToRS, TestSize.Level1)
793 {
794 ASSERT_NE(nullptr, ssm_);
795 AbilityRuntime::ApplicationContext::applicationContext_ = std::make_shared<AbilityRuntime::ApplicationContext>();
796 ASSERT_NE(nullptr, AbilityRuntime::ApplicationContext::applicationContext_);
797 AbilityRuntime::ApplicationContext::applicationContext_->contextImpl_ =
798 std::make_shared<AbilityRuntime::ContextImpl>();
799 ASSERT_NE(nullptr, AbilityRuntime::ApplicationContext::applicationContext_->contextImpl_);
800 AbilityRuntime::ApplicationContext::applicationContext_->contextImpl_->config_ =
801 std::make_shared<AppExecFwk::Configuration>();
802 ASSERT_NE(nullptr, AbilityRuntime::ApplicationContext::applicationContext_->GetConfiguration());
803 ssm_->UpdateDarkColorModeToRS();
804 }
805
806 /**
807 * @tc.name: NotifySessionAINavigationBarChange
808 * @tc.desc: NotifySessionAINavigationBarChange
809 * @tc.type: FUNC
810 */
811 HWTEST_F(SceneSessionManagerTest4, NotifySessionAINavigationBarChange, TestSize.Level1)
812 {
813 ASSERT_NE(nullptr, ssm_);
814 SessionInfo info;
815 info.abilityName_ = "SetBrightness";
816 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
817 ASSERT_NE(sceneSession, nullptr);
818 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession));
819 ssm_->NotifySessionAINavigationBarChange(0);
820 ssm_->NotifySessionAINavigationBarChange(1);
821
822 ASSERT_NE(sceneSession->property_, nullptr);
823 sceneSession->property_->type_ = WindowType::APP_SUB_WINDOW_END;
824 sceneSession->state_ = SessionState::STATE_ACTIVE;
825 ssm_->NotifySessionAINavigationBarChange(1);
826 EXPECT_EQ(WSError::WS_ERROR_INVALID_SESSION, ssm_->HandleSecureSessionShouldHide(nullptr));
827
828 ssm_->sceneSessionMap_.clear();
829 auto persistentId = sceneSession->GetPersistentId();
830 ssm_->sceneSessionMap_.insert({ persistentId, sceneSession });
831
832 sceneSession->SetScbCoreEnabled(true);
833 sceneSession->isVisible_ = true;
834 sceneSession->state_ = SessionState::STATE_FOREGROUND;
835 ssm_->NotifySessionAINavigationBarChange(persistentId);
836 EXPECT_EQ(WSError::WS_OK, ssm_->HandleSecureSessionShouldHide(sceneSession));
837 }
838
839 /**
840 * @tc.name: UpdateNormalSessionAvoidArea
841 * @tc.desc: UpdateNormalSessionAvoidArea
842 * @tc.type: FUNC
843 */
844 HWTEST_F(SceneSessionManagerTest4, UpdateNormalSessionAvoidArea, TestSize.Level1)
845 {
846 ASSERT_NE(nullptr, ssm_);
847 int32_t persistentId = 1;
848 sptr<SceneSession> sceneSession = nullptr;
849 bool needUpdate = true;
850 ssm_->UpdateNormalSessionAvoidArea(persistentId, sceneSession, needUpdate);
851 EXPECT_EQ(needUpdate, false);
852
853 SessionInfo info;
854 info.abilityName_ = "SetBrightness";
855 sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
856 ASSERT_NE(sceneSession, nullptr);
857 ASSERT_NE(sceneSession->property_, nullptr);
858 sceneSession->property_->type_ = WindowType::APP_SUB_WINDOW_BASE;
859 needUpdate = true;
860 ssm_->UpdateNormalSessionAvoidArea(persistentId, sceneSession, needUpdate);
861 EXPECT_EQ(needUpdate, false);
862
863 sceneSession->property_->type_ = WindowType::APP_SUB_WINDOW_END;
864 sceneSession->isVisible_ = true;
865 needUpdate = true;
866 ssm_->UpdateNormalSessionAvoidArea(persistentId, sceneSession, needUpdate);
867 EXPECT_EQ(needUpdate, false);
868
869 ssm_->avoidAreaListenerSessionSet_.insert(1);
870 ssm_->UpdateNormalSessionAvoidArea(persistentId, sceneSession, needUpdate);
871 EXPECT_EQ(WSError::WS_ERROR_INVALID_SESSION, ssm_->HandleSecureSessionShouldHide(nullptr));
872 }
873
874 /**
875 * @tc.name: UpdateRootSceneSessionAvoidArea
876 * @tc.desc: UpdateRootSceneSessionAvoidArea
877 * @tc.type: FUNC
878 */
879 HWTEST_F(SceneSessionManagerTest4, UpdateRootSceneSessionAvoidArea, TestSize.Level1)
880 {
881 ASSERT_NE(nullptr, ssm_);
882 int32_t persistentId = 1;
883 ssm_->rootSceneSession_ = sptr<RootSceneSession>::MakeSptr();
884 ASSERT_NE(nullptr, ssm_->rootSceneSession_);
885 bool needUpdate = false;
886 ssm_->UpdateRootSceneSessionAvoidArea(persistentId, needUpdate);
887 }
888
889 /**
890 * @tc.name: UpdateAvoidSessionAvoidArea
891 * @tc.desc: UpdateAvoidSessionAvoidArea
892 * @tc.type: FUNC
893 */
894 HWTEST_F(SceneSessionManagerTest4, UpdateAvoidSessionAvoidArea, TestSize.Level1)
895 {
896 ASSERT_NE(nullptr, ssm_);
897 ssm_->avoidAreaListenerSessionSet_.insert(0);
898 ssm_->avoidAreaListenerSessionSet_.insert(1);
899 SessionInfo info;
900 info.abilityName_ = "SetBrightness";
901 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
902 ASSERT_NE(sceneSession, nullptr);
903 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession));
904 WindowType type = WindowType::WINDOW_TYPE_INPUT_METHOD_FLOAT;
905 ssm_->UpdateAvoidSessionAvoidArea(type);
906
907 ASSERT_NE(sceneSession->property_, nullptr);
908 sceneSession->property_->type_ = WindowType::APP_MAIN_WINDOW_END;
909 sceneSession->isVisible_ = true;
910 ssm_->UpdateAvoidSessionAvoidArea(type);
911 EXPECT_EQ(WSError::WS_ERROR_INVALID_SESSION, ssm_->HandleSecureSessionShouldHide(nullptr));
912 }
913
914 /**
915 * @tc.name: FindSessionByAffinity
916 * @tc.desc: FindSessionByAffinity
917 * @tc.type: FUNC
918 */
919 HWTEST_F(SceneSessionManagerTest4, FindSessionByAffinity, TestSize.Level1)
920 {
921 ASSERT_NE(nullptr, ssm_);
922 std::string affinity = "";
923 sptr<SceneSession> sceneSession = ssm_->FindSessionByAffinity(affinity);
924 EXPECT_EQ(sceneSession, nullptr);
925 }
926
927 /**
928 * @tc.name: SetSystemAnimatedScenes
929 * @tc.desc: SetSystemAnimatedScenes
930 * @tc.type: FUNC
931 */
932 HWTEST_F(SceneSessionManagerTest4, SetSystemAnimatedScenes, TestSize.Level1)
933 {
934 ASSERT_NE(nullptr, ssm_);
935 SystemAnimatedSceneType sceneType = SystemAnimatedSceneType::SCENE_ENTER_MISSION_CENTER;
936 auto result = ssm_->SetSystemAnimatedScenes(sceneType);
937 EXPECT_EQ(result, WMError::WM_OK);
938 }
939
940 /**
941 * @tc.name: GetProcessDrawingState
942 * @tc.desc: GetProcessDrawingState
943 * @tc.type: FUNC
944 */
945 HWTEST_F(SceneSessionManagerTest4, GetProcessDrawingState, TestSize.Level1)
946 {
947 ASSERT_NE(nullptr, ssm_);
948 uint64_t windowId = 10;
949 int32_t pid = 1;
950 SessionInfo info;
951 info.abilityName_ = "SetBrightness";
952 sptr<SceneSession> sceneSession01 = nullptr;
953 sptr<SceneSession> sceneSession02 = sptr<SceneSession>::MakeSptr(info, nullptr);
954 sptr<SceneSession> sceneSession03 = sptr<SceneSession>::MakeSptr(info, nullptr);
955 sptr<SceneSession> sceneSession04 = sptr<SceneSession>::MakeSptr(info, nullptr);
956 ASSERT_NE(sceneSession02, nullptr);
957 ASSERT_NE(sceneSession03, nullptr);
958 ASSERT_NE(sceneSession04, nullptr);
959 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession01));
960 ssm_->sceneSessionMap_.insert(std::make_pair(2, sceneSession02));
961 ssm_->sceneSessionMap_.insert(std::make_pair(3, sceneSession03));
962 ssm_->sceneSessionMap_.insert(std::make_pair(4, sceneSession04));
963 sceneSession02->SetCallingPid(pid);
964 struct RSSurfaceNodeConfig config;
965 sceneSession02->surfaceNode_ = RSSurfaceNode::Create(config);
966 ASSERT_NE(sceneSession02->surfaceNode_, nullptr);
967 sceneSession03->SetCallingPid(pid);
968 sceneSession03->surfaceNode_ = nullptr;
969 sceneSession04->SetCallingPid(6);
970 auto result = ssm_->GetProcessDrawingState(windowId, pid);
971 EXPECT_EQ(result, true);
972 }
973
974 /**
975 * @tc.name: GetPreWindowDrawingState
976 * @tc.desc: GetPreWindowDrawingState
977 * @tc.type: FUNC
978 */
979 HWTEST_F(SceneSessionManagerTest4, GetPreWindowDrawingState, TestSize.Level1)
980 {
981 ASSERT_NE(nullptr, ssm_);
982 uint64_t surfaceId = 0;
983 int32_t pid = 10;
984 bool result = ssm_->GetPreWindowDrawingState(surfaceId, true, pid);
985 EXPECT_EQ(result, false);
986
987 SessionInfo info;
988 info.abilityName_ = "SetBrightness";
989 sptr<SceneSession> sceneSession01 = sptr<SceneSession>::MakeSptr(info, nullptr);
990 ASSERT_NE(sceneSession01, nullptr);
991 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession01));
992 struct RSSurfaceNodeConfig config;
993 sceneSession01->surfaceNode_ = RSSurfaceNode::Create(config);
994 ASSERT_NE(sceneSession01->surfaceNode_, nullptr);
995 sceneSession01->surfaceNode_->id_ = 10;
996 surfaceId = 10;
997 result = ssm_->GetPreWindowDrawingState(surfaceId, true, pid);
998 EXPECT_EQ(result, false);
999 }
1000
1001 /**
1002 * @tc.name: GetWindowDrawingContentChangeInfo
1003 * @tc.desc: GetWindowDrawingContentChangeInfo
1004 * @tc.type: FUNC
1005 */
1006 HWTEST_F(SceneSessionManagerTest4, GetWindowDrawingContentChangeInfo, TestSize.Level1)
1007 {
1008 ASSERT_NE(nullptr, ssm_);
1009 SessionInfo info;
1010 info.abilityName_ = "SetBrightness";
1011 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
1012 ASSERT_NE(sceneSession, nullptr);
1013 ssm_->sceneSessionMap_.insert(std::make_pair(0, nullptr));
1014 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession));
1015
1016 std::vector<std::pair<uint64_t, bool>> currDrawingContentData;
1017 currDrawingContentData.push_back(std::make_pair(0, false));
1018 currDrawingContentData.push_back(std::make_pair(1, true));
1019
1020 struct RSSurfaceNodeConfig config;
1021 sceneSession->surfaceNode_ = RSSurfaceNode::Create(config);
1022 ASSERT_NE(sceneSession->surfaceNode_, nullptr);
1023 sceneSession->surfaceNode_->id_ = 0;
1024 sceneSession->SetCallingPid(0);
1025 sceneSession->SetDrawingContentState(true);
1026
1027 auto result = ssm_->GetWindowDrawingContentChangeInfo(currDrawingContentData);
1028 EXPECT_EQ(result, currDrawingContentData);
1029
1030 sceneSession->SetCallingPid(2);
1031 result = ssm_->GetWindowDrawingContentChangeInfo(currDrawingContentData);
1032 EXPECT_NE(result, currDrawingContentData);
1033 }
1034
1035 /**
1036 * @tc.name: GetWindowDrawingContentChangeInfo02
1037 * @tc.desc: GetWindowDrawingContentChangeInfo02
1038 * @tc.type: FUNC
1039 */
1040 HWTEST_F(SceneSessionManagerTest4, GetWindowDrawingContentChangeInfo02, TestSize.Level1)
1041 {
1042 ASSERT_NE(nullptr, ssm_);
1043 SessionInfo info;
1044 info.abilityName_ = "GetWindowDrawingContentChangeInfo02";
1045 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
1046 ASSERT_NE(sceneSession, nullptr);
1047 ssm_->sceneSessionMap_.insert(std::make_pair(0, nullptr));
1048
1049 std::vector<std::pair<uint64_t, bool>> currDrawingContentData;
1050 currDrawingContentData.push_back(std::make_pair(0, false));
1051 currDrawingContentData.push_back(std::make_pair(1, true));
1052
1053 auto result = ssm_->GetWindowDrawingContentChangeInfo(currDrawingContentData);
1054 EXPECT_EQ(result, currDrawingContentData);
1055 }
1056
1057 /**
1058 * @tc.name: DealwithDrawingContentChange
1059 * @tc.desc: DealwithDrawingContentChange
1060 * @tc.type: FUNC
1061 */
1062 HWTEST_F(SceneSessionManagerTest4, DealwithDrawingContentChange, TestSize.Level1)
1063 {
1064 ASSERT_NE(nullptr, ssm_);
1065 SessionInfo info;
1066 info.abilityName_ = "SetBrightness";
1067 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
1068 ASSERT_NE(sceneSession, nullptr);
1069 ssm_->sceneSessionMap_.insert(std::make_pair(0, nullptr));
1070
1071 std::vector<std::pair<uint64_t, bool>> drawingContentChangeInfo;
1072 drawingContentChangeInfo.push_back(std::make_pair(0, true));
1073 drawingContentChangeInfo.push_back(std::make_pair(1, true));
1074 ssm_->DealwithDrawingContentChange(drawingContentChangeInfo);
1075
1076 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession));
1077 struct RSSurfaceNodeConfig config;
1078 sceneSession->surfaceNode_ = RSSurfaceNode::Create(config);
1079 ASSERT_NE(sceneSession->surfaceNode_, nullptr);
1080 sceneSession->surfaceNode_->id_ = 1;
1081 ssm_->DealwithDrawingContentChange(drawingContentChangeInfo);
1082
1083 ssm_->openDebugTrace_ = true;
1084 ssm_->DealwithDrawingContentChange(drawingContentChangeInfo);
1085 EXPECT_EQ(WSError::WS_ERROR_INVALID_SESSION, ssm_->HandleSecureSessionShouldHide(nullptr));
1086 }
1087
1088 /**
1089 * @tc.name: GetSubSceneSession
1090 * @tc.desc: GetSubSceneSession
1091 * @tc.type: FUNC
1092 */
1093 HWTEST_F(SceneSessionManagerTest4, GetSubSceneSession, TestSize.Level1)
1094 {
1095 ASSERT_NE(nullptr, ssm_);
1096 SessionInfo info;
1097 info.abilityName_ = "GetSubSceneSession";
1098 sptr<SceneSession> sceneSession01 = sptr<SceneSession>::MakeSptr(info, nullptr);
1099 sptr<SceneSession> sceneSession02 = sptr<SceneSession>::MakeSptr(info, nullptr);
1100 sptr<SceneSession> sceneSession03 = sptr<SceneSession>::MakeSptr(info, nullptr);
1101 sptr<Session> session04 = sptr<Session>::MakeSptr(info);
1102 sptr<Session> session05 = sptr<Session>::MakeSptr(info);
1103 ASSERT_NE(sceneSession01, nullptr);
1104 ASSERT_NE(sceneSession02, nullptr);
1105 ASSERT_NE(sceneSession03, nullptr);
1106 ASSERT_NE(session04, nullptr);
1107 ASSERT_NE(session05, nullptr);
1108 sceneSession01->persistentId_ = 1;
1109 sceneSession02->persistentId_ = 2;
1110 sceneSession03->persistentId_ = 3;
1111 session04->persistentId_ = 4;
1112 session05->persistentId_ = 5;
1113 ssm_->sceneSessionMap_.insert(std::make_pair(0, nullptr));
1114 ssm_->sceneSessionMap_.insert(std::make_pair(sceneSession01->GetPersistentId(), sceneSession01));
1115 ssm_->sceneSessionMap_.insert(std::make_pair(sceneSession02->GetPersistentId(), sceneSession02));
1116 ssm_->sceneSessionMap_.insert(std::make_pair(sceneSession03->GetPersistentId(), sceneSession03));
1117 session04->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1118 sceneSession01->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1119 sceneSession01->parentSession_ = session04;
1120 session05->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1121 sceneSession02->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1122 sceneSession02->parentSession_ = session05;
1123 sceneSession03->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1124 sceneSession03->parentSession_ = sceneSession01;
1125 std::vector<sptr<SceneSession>> subSessions = ssm_->GetSubSceneSession(session04->GetPersistentId());
1126 EXPECT_EQ(subSessions.size(), 2);
1127 }
1128
1129 /**
1130 * @tc.name: RemoveDuplicateSubSession
1131 * @tc.desc: RemoveDuplicateSubSession
1132 * @tc.type: FUNC
1133 */
1134 HWTEST_F(SceneSessionManagerTest4, RemoveDuplicateSubSession, TestSize.Level1)
1135 {
1136 ASSERT_NE(nullptr, ssm_);
1137 std::vector<std::pair<uint64_t, WindowVisibilityState>> visibilityChangeInfo;
1138 std::vector<sptr<SceneSession>> subSessions;
1139 visibilityChangeInfo.push_back(std::make_pair(0, WINDOW_VISIBILITY_STATE_NO_OCCLUSION));
1140 visibilityChangeInfo.push_back(std::make_pair(1, WINDOW_VISIBILITY_STATE_PARTICALLY_OCCLUSION));
1141
1142 SessionInfo info;
1143 info.abilityName_ = "SetBrightness";
1144 sptr<SceneSession> sceneSession01 = sptr<SceneSession>::MakeSptr(info, nullptr);
1145 sptr<SceneSession> sceneSession02 = sptr<SceneSession>::MakeSptr(info, nullptr);
1146 sptr<SceneSession> sceneSession03 = nullptr;
1147 ASSERT_NE(sceneSession01, nullptr);
1148 ASSERT_NE(sceneSession02, nullptr);
1149 struct RSSurfaceNodeConfig config;
1150 sceneSession01->surfaceNode_ = RSSurfaceNode::Create(config);
1151 ASSERT_NE(sceneSession01->surfaceNode_, nullptr);
1152 sceneSession01->surfaceNode_->id_ = 0;
1153
1154 ssm_->sceneSessionMap_.insert(std::make_pair(0, nullptr));
1155 ssm_->RemoveDuplicateSubSession(visibilityChangeInfo, subSessions);
1156
1157 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession01));
1158 sceneSession02->persistentId_ = 2;
1159 subSessions.push_back(sceneSession01);
1160 subSessions.push_back(sceneSession02);
1161 subSessions.push_back(sceneSession03);
1162 ssm_->RemoveDuplicateSubSession(visibilityChangeInfo, subSessions);
1163 EXPECT_EQ(WSError::WS_ERROR_INVALID_SESSION, ssm_->HandleSecureSessionShouldHide(nullptr));
1164 }
1165
1166 /**
1167 * @tc.name: UpdateSubWindowVisibility
1168 * @tc.desc: UpdateSubWindowVisibility
1169 * @tc.type: FUNC
1170 */
1171 HWTEST_F(SceneSessionManagerTest4, UpdateSubWindowVisibility, TestSize.Level1)
1172 {
1173 ASSERT_NE(nullptr, ssm_);
1174 SessionInfo info;
1175 info.abilityName_ = "SetBrightness";
1176 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
1177 ASSERT_NE(sceneSession, nullptr);
1178 WindowVisibilityState visibleState = WINDOW_VISIBILITY_STATE_TOTALLY_OCCUSION;
1179 std::vector<std::pair<uint64_t, WindowVisibilityState>> visibilityChangeInfo;
1180 std::vector<sptr<WindowVisibilityInfo>> windowVisibilityInfos;
1181 std::string visibilityInfo = "";
1182 std::vector<std::pair<uint64_t, WindowVisibilityState>> currVisibleData;
1183 ssm_->UpdateSubWindowVisibility(
1184 sceneSession, visibleState, visibilityChangeInfo, windowVisibilityInfos, visibilityInfo, currVisibleData);
1185
1186 ASSERT_NE(sceneSession->property_, nullptr);
1187 sceneSession->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
1188 ssm_->UpdateSubWindowVisibility(
1189 sceneSession, visibleState, visibilityChangeInfo, windowVisibilityInfos, visibilityInfo, currVisibleData);
1190
1191 sceneSession->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1192 visibleState = WINDOW_VISIBILITY_STATE_PARTICALLY_OCCLUSION;
1193 ssm_->sceneSessionMap_.insert(std::make_pair(0, nullptr));
1194 ssm_->UpdateSubWindowVisibility(
1195 sceneSession, visibleState, visibilityChangeInfo, windowVisibilityInfos, visibilityInfo, currVisibleData);
1196
1197 sptr<SceneSession> sceneSession01 = sptr<SceneSession>::MakeSptr(info, nullptr);
1198 sptr<SceneSession> sceneSession02 = sptr<SceneSession>::MakeSptr(info, nullptr);
1199 sptr<SceneSession> sceneSession03 = sptr<SceneSession>::MakeSptr(info, nullptr);
1200 sptr<Session> session03 = sptr<Session>::MakeSptr(info);
1201 ASSERT_NE(sceneSession01, nullptr);
1202 ASSERT_NE(sceneSession02, nullptr);
1203 ASSERT_NE(sceneSession03, nullptr);
1204 ASSERT_NE(session03, nullptr);
1205 sceneSession01->SetParentSession(session03);
1206 sceneSession02->SetParentSession(session03);
1207 sceneSession03->SetParentSession(session03);
1208 sceneSession02->SetCallingPid(2);
1209 sceneSession03->SetCallingPid(3);
1210 sceneSession03->state_ = SessionState::STATE_FOREGROUND;
1211 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession01));
1212 ssm_->sceneSessionMap_.insert(std::make_pair(2, sceneSession02));
1213 ssm_->sceneSessionMap_.insert(std::make_pair(3, sceneSession03));
1214 ssm_->UpdateSubWindowVisibility(
1215 sceneSession, visibleState, visibilityChangeInfo, windowVisibilityInfos, visibilityInfo, currVisibleData);
1216 EXPECT_EQ(WSError::WS_ERROR_INVALID_SESSION, ssm_->HandleSecureSessionShouldHide(nullptr));
1217 }
1218
1219 /**
1220 * @tc.name: SelectSesssionFromMap
1221 * @tc.desc: SelectSesssionFromMap
1222 * @tc.type: FUNC
1223 */
1224 HWTEST_F(SceneSessionManagerTest4, SelectSesssionFromMap, TestSize.Level1)
1225 {
1226 ASSERT_NE(nullptr, ssm_);
1227 uint64_t surfaceId = 6;
1228 uint64_t surfaceId02 = 7;
1229 SessionInfo info;
1230 info.abilityName_ = "SetBrightness";
1231 sptr<SceneSession> sceneSession;
1232 sptr<SceneSession> sceneSession01 = sptr<SceneSession>::MakeSptr(info, nullptr);
1233 sptr<SceneSession> sceneSession02 = sptr<SceneSession>::MakeSptr(info, nullptr);
1234 ASSERT_NE(sceneSession01, nullptr);
1235 ASSERT_NE(sceneSession02, nullptr);
1236 ssm_->sceneSessionMap_.insert(std::make_pair(0, sceneSession));
1237 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession01));
1238 ssm_->sceneSessionMap_.insert(std::make_pair(2, sceneSession02));
1239 sceneSession01->surfaceNode_ = nullptr;
1240 struct RSSurfaceNodeConfig config;
1241 sceneSession02->surfaceNode_ = RSSurfaceNode::Create(config);
1242 ASSERT_NE(sceneSession02->surfaceNode_, nullptr);
1243 NodeId id = 6;
1244 sceneSession02->surfaceNode_->SetId(id);
1245 EXPECT_EQ(sceneSession02->surfaceNode_->id_, 6);
1246
1247 sptr<SceneSession> result = ssm_->SelectSesssionFromMap(surfaceId);
1248 EXPECT_EQ(result, sceneSession02);
1249 result = ssm_->SelectSesssionFromMap(surfaceId02);
1250 EXPECT_EQ(result, nullptr);
1251 }
1252
1253 /**
1254 * @tc.name: GetAccessibilityWindowInfo
1255 * @tc.desc: GetAccessibilityWindowInfo
1256 * @tc.type: FUNC
1257 */
1258 HWTEST_F(SceneSessionManagerTest4, GetAccessibilityWindowInfo, TestSize.Level1)
1259 {
1260 ASSERT_NE(nullptr, ssm_);
1261 SessionInfo info;
1262 info.abilityName_ = "SetBrightness";
1263 sptr<SceneSession> sceneSession;
1264 sptr<SceneSession> sceneSession01 = sptr<SceneSession>::MakeSptr(info, nullptr);
1265 sptr<SceneSession> sceneSession02 = sptr<SceneSession>::MakeSptr(info, nullptr);
1266 sptr<SceneSession> sceneSession03 = sptr<SceneSession>::MakeSptr(info, nullptr);
1267 sptr<SceneSession> sceneSession04 = sptr<SceneSession>::MakeSptr(info, nullptr);
1268 ASSERT_NE(sceneSession01, nullptr);
1269 ASSERT_NE(sceneSession02, nullptr);
1270 ASSERT_NE(sceneSession03, nullptr);
1271 ASSERT_NE(sceneSession04, nullptr);
1272 sceneSession01->SetForceTouchable(true);
1273 sceneSession01->isVisible_ = true;
1274 ASSERT_NE(sceneSession01->property_, nullptr);
1275 sceneSession01->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
1276 sceneSession01->property_->SetParentPersistentId(4);
1277 sceneSession02->SetForceTouchable(false);
1278 sceneSession03->SetForceTouchable(true);
1279 sceneSession03->isVisible_ = true;
1280 ASSERT_NE(sceneSession03->property_, nullptr);
1281 sceneSession03->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
1282 sceneSession03->property_->SetParentPersistentId(6);
1283 ssm_->sceneSessionMap_.insert(std::make_pair(0, sceneSession));
1284 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession01));
1285 ssm_->sceneSessionMap_.insert(std::make_pair(2, sceneSession02));
1286 ssm_->sceneSessionMap_.insert(std::make_pair(3, sceneSession03));
1287 ssm_->sceneSessionMap_.insert(std::make_pair(4, sceneSession04));
1288 std::vector<sptr<AccessibilityWindowInfo>> accessibilityInfo;
1289 auto result = ssm_->GetAccessibilityWindowInfo(accessibilityInfo);
1290 EXPECT_EQ(result, WMError::WM_OK);
1291 }
1292
1293 /**
1294 * @tc.name: ShiftAppWindowFocus02
1295 * @tc.desc: ShiftAppWindowFocus
1296 * @tc.type: FUNC
1297 */
1298 HWTEST_F(SceneSessionManagerTest4, ShiftAppWindowFocus02, TestSize.Level1)
1299 {
1300 ASSERT_NE(ssm_, nullptr);
1301 ssm_->SetFocusedSessionId(INVALID_SESSION_ID, DEFAULT_DISPLAY_ID);
1302 int32_t sourcePersistentId = INVALID_SESSION_ID;
1303 int32_t targetPersistentId = 1;
1304
1305 auto result = ssm_->ShiftAppWindowFocus(sourcePersistentId, targetPersistentId);
1306 EXPECT_EQ(result, WSError::WS_ERROR_INVALID_SESSION);
1307
1308 SessionInfo info;
1309 info.abilityName_ = "abilityName";
1310 info.bundleName_ = "bundleName";
1311 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
1312 ssm_->sceneSessionMap_.insert(std::make_pair(INVALID_SESSION_ID, sceneSession));
1313 sceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1314 result = ssm_->ShiftAppWindowFocus(sourcePersistentId, targetPersistentId);
1315 EXPECT_EQ(result, WSError::WS_ERROR_INVALID_SESSION);
1316
1317 SessionInfo info01;
1318 info01.abilityName_ = "abilityName01";
1319 info01.bundleName_ = "bundleName01";
1320 sptr<SceneSession> sceneSession01 = sptr<SceneSession>::MakeSptr(info01, nullptr);
1321 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession01));
1322 sceneSession01->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1323 result = ssm_->ShiftAppWindowFocus(sourcePersistentId, targetPersistentId);
1324 EXPECT_EQ(result, WSError::WS_ERROR_INVALID_CALLING);
1325 }
1326
1327 /**
1328 * @tc.name: UpdateTitleInTargetPos
1329 * @tc.desc: UpdateTitleInTargetPos
1330 * @tc.type: FUNC
1331 */
1332 HWTEST_F(SceneSessionManagerTest4, UpdateTitleInTargetPos, TestSize.Level1)
1333 {
1334 ASSERT_NE(ssm_, nullptr);
1335 SessionInfo info;
1336 info.abilityName_ = "abilityName";
1337 info.bundleName_ = "bundleName";
1338 info.isSystem_ = true;
1339 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
1340 ASSERT_NE(sceneSession, nullptr);
1341 ssm_->sceneSessionMap_.insert(std::make_pair(0, sceneSession));
1342 auto result = ssm_->UpdateTitleInTargetPos(1, true, 1);
1343 ASSERT_EQ(result, WSError::WS_ERROR_INVALID_WINDOW);
1344
1345 result = ssm_->UpdateTitleInTargetPos(0, true, 1);
1346 EXPECT_EQ(result, WSError::WS_ERROR_INVALID_SESSION);
1347 }
1348
1349 /**
1350 * @tc.name: GetIsLayoutFullScreen
1351 * @tc.desc: GetIsLayoutFullScreen
1352 * @tc.type: FUNC
1353 */
1354 HWTEST_F(SceneSessionManagerTest4, GetIsLayoutFullScreen, TestSize.Level1)
1355 {
1356 ASSERT_NE(ssm_, nullptr);
1357 SessionInfo info;
1358 info.abilityName_ = "abilityName";
1359 info.bundleName_ = "bundleName";
1360 sptr<SceneSession> sceneSession01 = sptr<SceneSession>::MakeSptr(info, nullptr);
1361 sptr<SceneSession> sceneSession02 = sptr<SceneSession>::MakeSptr(info, nullptr);
1362 sptr<SceneSession> sceneSession03 = sptr<SceneSession>::MakeSptr(info, nullptr);
1363 sptr<SceneSession> sceneSession04 = sptr<SceneSession>::MakeSptr(info, nullptr);
1364 ASSERT_NE(sceneSession01, nullptr);
1365 ASSERT_NE(sceneSession02, nullptr);
1366 ASSERT_NE(sceneSession03, nullptr);
1367 ASSERT_NE(sceneSession04, nullptr);
1368 ASSERT_NE(sceneSession01->property_, nullptr);
1369 sceneSession01->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
1370
1371 ASSERT_NE(sceneSession02->property_, nullptr);
1372 sceneSession02->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1373 sceneSession02->SetSessionState(SessionState::STATE_DISCONNECT);
1374
1375 ASSERT_NE(sceneSession03->property_, nullptr);
1376 sceneSession03->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1377 sceneSession03->SetSessionState(SessionState::STATE_ACTIVE);
1378 sceneSession03->property_->SetWindowMode(WindowMode::WINDOW_MODE_UNDEFINED);
1379
1380 ASSERT_NE(sceneSession04->property_, nullptr);
1381 sceneSession04->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1382 sceneSession04->SetSessionState(SessionState::STATE_FOREGROUND);
1383 sceneSession04->property_->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1384 sceneSession04->property_->SetIsLayoutFullScreen(true);
1385
1386 ASSERT_NE(sceneSession04->property_, nullptr);
1387 sceneSession04->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1388 sceneSession04->SetSessionState(SessionState::STATE_FOREGROUND);
1389 sceneSession04->property_->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1390 sceneSession04->property_->SetIsLayoutFullScreen(false);
1391
1392 ssm_->sceneSessionMap_.insert(std::make_pair(0, nullptr));
1393 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession01));
1394 ssm_->sceneSessionMap_.insert(std::make_pair(2, sceneSession02));
1395 ssm_->sceneSessionMap_.insert(std::make_pair(3, sceneSession03));
1396 bool isLayoutFullScreen = true;
1397 auto result = ssm_->GetIsLayoutFullScreen(isLayoutFullScreen);
1398 EXPECT_EQ(result, WSError::WS_OK);
1399 }
1400
1401 /**
1402 * @tc.name: UpdateExtWindowFlags
1403 * @tc.desc: UpdateExtWindowFlags
1404 * @tc.type: FUNC
1405 */
1406 HWTEST_F(SceneSessionManagerTest4, UpdateExtWindowFlags, TestSize.Level1)
1407 {
1408 ASSERT_NE(ssm_, nullptr);
1409 uint32_t extWindowFlags = 0;
1410 uint32_t extWindowActions = 0;
1411 auto ret = ssm_->UpdateExtWindowFlags(nullptr, extWindowFlags, extWindowActions);
1412 EXPECT_EQ(ret, WSError::WS_OK);
1413 }
1414
1415 /**
1416 * @tc.name: AddOrRemoveSecureSession02
1417 * @tc.desc: AddOrRemoveSecureSession
1418 * @tc.type: FUNC
1419 */
1420 HWTEST_F(SceneSessionManagerTest4, AddOrRemoveSecureSession02, TestSize.Level1)
1421 {
1422 ASSERT_NE(ssm_, nullptr);
1423 int32_t persistentId = 1;
1424 bool shouldHide = true;
1425 SessionInfo info;
1426 info.abilityName_ = "secureSession";
1427 info.bundleName_ = "secureSession";
1428 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
1429 ASSERT_NE(sceneSession, nullptr);
1430 ssm_->sceneSessionMap_.insert(std::make_pair(0, nullptr));
1431 ssm_->sceneSessionMap_.insert(std::make_pair(persistentId, sceneSession));
1432 auto result = ssm_->AddOrRemoveSecureSession(0, shouldHide);
1433 EXPECT_EQ(result, WSError::WS_OK);
1434 result = ssm_->AddOrRemoveSecureSession(persistentId, shouldHide);
1435 EXPECT_EQ(result, WSError::WS_OK);
1436 static constexpr uint32_t WAIT_SYNC_IN_NS = 500000;
1437 usleep(WAIT_SYNC_IN_NS);
1438 }
1439
1440 /**
1441 * @tc.name: GetSessionSnapshotPixelMap
1442 * @tc.desc: GetSessionSnapshotPixelMap
1443 * @tc.type: FUNC
1444 */
1445 HWTEST_F(SceneSessionManagerTest4, GetSessionSnapshotPixelMap, TestSize.Level1)
1446 {
1447 ASSERT_NE(ssm_, nullptr);
1448 SessionInfo info;
1449 info.abilityName_ = "GetPixelMap";
1450 info.bundleName_ = "GetPixelMap1";
1451 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
1452 ASSERT_NE(sceneSession, nullptr);
1453 sceneSession->SetSessionState(SessionState::STATE_ACTIVE);
1454 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession));
1455 int32_t persistentId = 1;
1456 float scaleParam = 0.5f;
1457 auto result = ssm_->GetSessionSnapshotPixelMap(persistentId, scaleParam);
1458 EXPECT_EQ(result, nullptr);
1459
1460 sceneSession->SetSessionState(SessionState::STATE_FOREGROUND);
1461 std::string bundleName = "testBundleName";
1462 int32_t testpersistentId = 1;
1463 sceneSession->scenePersistence_ = sptr<ScenePersistence>::MakeSptr(bundleName, testpersistentId);
1464 ASSERT_NE(sceneSession->scenePersistence_, nullptr);
1465 struct RSSurfaceNodeConfig config;
1466 sceneSession->surfaceNode_ = RSSurfaceNode::Create(config);
1467 ASSERT_NE(sceneSession->surfaceNode_, nullptr);
1468 sceneSession->bufferAvailable_ = true;
1469 result = ssm_->GetSessionSnapshotPixelMap(persistentId, scaleParam);
1470 EXPECT_EQ(result, nullptr);
1471 }
1472
1473 /**
1474 * @tc.name: HandleHideNonSystemFloatingWindows
1475 * @tc.desc: HandleHideNonSystemFloatingWindows
1476 * @tc.type: FUNC
1477 */
1478 HWTEST_F(SceneSessionManagerTest4, HandleHideNonSystemFloatingWindows, TestSize.Level1)
1479 {
1480 ASSERT_NE(ssm_, nullptr);
1481 SessionInfo info;
1482 info.abilityName_ = "abilityName";
1483 info.bundleName_ = "bundleName";
1484 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
1485 ASSERT_NE(property, nullptr);
1486 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
1487 ASSERT_NE(sceneSession, nullptr);
1488
1489 sceneSession->property_->hideNonSystemFloatingWindows_ = true;
1490 property->SetHideNonSystemFloatingWindows(false);
1491 sceneSession->isVisible_ = true;
1492 sceneSession->state_ = SessionState::STATE_FOREGROUND;
1493 ssm_->HandleHideNonSystemFloatingWindows(property, sceneSession);
1494
1495 sceneSession->property_->hideNonSystemFloatingWindows_ = false;
1496 property->SetHideNonSystemFloatingWindows(true);
1497 ssm_->HandleHideNonSystemFloatingWindows(property, sceneSession);
1498
1499 sceneSession->isVisible_ = false;
1500 ssm_->HandleHideNonSystemFloatingWindows(property, sceneSession);
1501 EXPECT_EQ(Session::IsScbCoreEnabled(), true);
1502 }
1503
1504 /**
1505 * @tc.name: GetAllClearableSessions
1506 * @tc.desc: GetAllClearableSessions
1507 * @tc.type: FUNC
1508 */
1509 HWTEST_F(SceneSessionManagerTest4, GetAllClearableSessions, TestSize.Level1)
1510 {
1511 SessionInfo sessionInfo;
1512 sessionInfo.bundleName_ = "bundleName";
1513 sessionInfo.abilityName_ = "abilityName";
1514 sessionInfo.abilityInfo = nullptr;
1515 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
1516 ASSERT_NE(nullptr, ssm_);
1517 ASSERT_NE(nullptr, sceneSession);
1518 ssm_->sceneSessionMap_.insert(std::make_pair(2, sceneSession));
1519 SessionInfo sessionInfo1;
1520 sessionInfo1.bundleName_ = "bundleName";
1521 sessionInfo1.abilityName_ = "abilityName";
1522 sessionInfo1.abilityInfo = std::make_shared<AppExecFwk::AbilityInfo>();
1523 ASSERT_NE(nullptr, sessionInfo1.abilityInfo);
1524 sessionInfo1.abilityInfo->excludeFromMissions = false;
1525 sessionInfo1.abilityInfo->unclearableMission = false;
1526 sessionInfo1.isSystem_ = false;
1527 sessionInfo1.lockedState = false;
1528 sptr<SceneSession> sceneSession1 = sptr<SceneSession>::MakeSptr(sessionInfo1, nullptr);
1529 ssm_->sceneSessionMap_.insert(std::make_pair(3, sceneSession1));
1530 std::vector<sptr<SceneSession>> sessionVector;
1531 sessionVector.clear();
1532 ssm_->GetAllClearableSessions(sessionVector);
1533 EXPECT_FALSE(sessionVector.empty());
1534 }
1535
1536 /**
1537 * @tc.name: UpdateBrightness
1538 * @tc.desc: UpdateBrightness
1539 * @tc.type: FUNC
1540 */
1541 HWTEST_F(SceneSessionManagerTest4, UpdateBrightness, TestSize.Level1)
1542 {
1543 ASSERT_NE(ssm_, nullptr);
1544 SessionInfo sessionInfo;
1545 sessionInfo.isSystem_ = false;
1546 sessionInfo.bundleName_ = "bundleName";
1547 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
1548 ASSERT_NE(sceneSession, nullptr);
1549 ASSERT_NE(sceneSession->property_, nullptr);
1550 sceneSession->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
1551 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession));
1552 ssm_->systemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
1553 WSError result = ssm_->UpdateBrightness(1);
1554 EXPECT_EQ(result, WSError::WS_DO_NOTHING);
1555
1556 SessionInfo sessionInfo02;
1557 sessionInfo02.isSystem_ = true;
1558 sessionInfo02.bundleName_ = "bundleName";
1559 sptr<SceneSession> sceneSession02 = sptr<SceneSession>::MakeSptr(sessionInfo02, nullptr);
1560 ASSERT_NE(sceneSession02, nullptr);
1561 ASSERT_NE(sceneSession02->property_, nullptr);
1562 ssm_->sceneSessionMap_.insert(std::make_pair(2, sceneSession02));
1563 sceneSession02->property_->SetBrightness(50.f);
1564 ssm_->SetDisplayBrightness(40.f);
1565 result = ssm_->UpdateBrightness(2);
1566 EXPECT_EQ(ssm_->displayBrightness_, 50);
1567 EXPECT_EQ(result, WSError::WS_OK);
1568 }
1569
1570 /**
1571 * @tc.name: RegisterSessionExceptionFunc
1572 * @tc.desc: RegisterSessionExceptionFunc
1573 * @tc.type: FUNC
1574 */
1575 HWTEST_F(SceneSessionManagerTest4, RegisterSessionExceptionFunc, TestSize.Level1)
1576 {
1577 ASSERT_NE(ssm_, nullptr);
1578 SessionInfo sessionInfo;
1579 sessionInfo.bundleName_ = "bundleName";
1580 sessionInfo.persistentId_ = 1;
1581 sessionInfo.isSystem_ = true;
1582 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
1583 ASSERT_NE(sceneSession, nullptr);
1584 ssm_->sceneSessionMap_.insert(std::make_pair(sessionInfo.persistentId_, sceneSession));
1585 std::shared_ptr<SessionListenerController> listenerController = std::make_shared<SessionListenerController>();
1586 ssm_->listenerController_ = listenerController;
1587 ASSERT_NE(ssm_->listenerController_, nullptr);
1588 ExceptionInfo exceptionInfo;
1589 ssm_->RegisterSessionExceptionFunc(sceneSession);
1590
1591 sptr<AAFwk::SessionInfo> abilitySessionInfo = sptr<AAFwk::SessionInfo>::MakeSptr();
1592 ASSERT_NE(abilitySessionInfo, nullptr);
1593 WSError result = sceneSession->NotifySessionExceptionInner(abilitySessionInfo, exceptionInfo, false);
1594 EXPECT_EQ(result, WSError::WS_OK);
1595
1596 abilitySessionInfo->errorCode = 1;
1597 result = sceneSession->NotifySessionExceptionInner(abilitySessionInfo, exceptionInfo, false);
1598 EXPECT_EQ(result, WSError::WS_OK);
1599
1600 abilitySessionInfo->errorCode = 0;
1601 result = sceneSession->NotifySessionExceptionInner(abilitySessionInfo, exceptionInfo, false);
1602 EXPECT_EQ(result, WSError::WS_OK);
1603
1604 sessionInfo.isSystem_ = false;
1605 result = sceneSession->NotifySessionExceptionInner(abilitySessionInfo, exceptionInfo, false);
1606 EXPECT_EQ(result, WSError::WS_OK);
1607
1608 ssm_->listenerController_ = nullptr;
1609 result = sceneSession->NotifySessionExceptionInner(abilitySessionInfo, exceptionInfo, false);
1610 EXPECT_EQ(result, WSError::WS_OK);
1611
1612 sessionInfo.persistentId_ = 2;
1613 result = sceneSession->NotifySessionExceptionInner(abilitySessionInfo, exceptionInfo, false);
1614 EXPECT_EQ(result, WSError::WS_OK);
1615 usleep(WAIT_SYNC_IN_NS);
1616 }
1617
1618 /**
1619 * @tc.name: RegisterSessionSnapshotFunc
1620 * @tc.desc: RegisterSessionSnapshotFunc
1621 * @tc.type: FUNC
1622 */
1623 HWTEST_F(SceneSessionManagerTest4, RegisterSessionSnapshotFunc, TestSize.Level1)
1624 {
1625 ASSERT_NE(ssm_, nullptr);
1626 SessionInfo sessionInfo;
1627 sessionInfo.bundleName_ = "bundleName";
1628 sessionInfo.persistentId_ = 1;
1629 sessionInfo.isSystem_ = false;
1630 sessionInfo.abilityInfo = std::make_shared<AppExecFwk::AbilityInfo>();
1631 ASSERT_NE(sessionInfo.abilityInfo, nullptr);
1632 sessionInfo.abilityInfo->excludeFromMissions = true;
1633 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
1634 ASSERT_NE(sceneSession, nullptr);
1635 sceneSession->scenePersistence_ = sptr<ScenePersistence>::MakeSptr("bundleName", 1);
1636 ASSERT_NE(sceneSession->scenePersistence_, nullptr);
1637 struct RSSurfaceNodeConfig rsSurfaceNodeConfig;
1638 sceneSession->surfaceNode_ = std::make_shared<RSSurfaceNode>(rsSurfaceNodeConfig, true, 0);
1639 ASSERT_NE(sceneSession->surfaceNode_, nullptr);
1640 sceneSession->surfaceNode_->bufferAvailable_ = true;
1641 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession));
1642 ssm_->listenerController_ = std::make_shared<SessionListenerController>();
1643 ASSERT_NE(ssm_->listenerController_, nullptr);
1644 ssm_->RegisterSessionSnapshotFunc(sceneSession);
1645 EXPECT_EQ(sceneSession->Snapshot(1.f), nullptr);
1646
1647 sessionInfo.abilityInfo->excludeFromMissions = false;
1648 EXPECT_EQ(sceneSession->Snapshot(1.f), nullptr);
1649
1650 ssm_->listenerController_ = nullptr;
1651 EXPECT_EQ(sceneSession->Snapshot(1.f), nullptr);
1652
1653 sessionInfo.abilityInfo = nullptr;
1654 EXPECT_EQ(sceneSession->Snapshot(1.f), nullptr);
1655
1656 sessionInfo.isSystem_ = true;
1657 EXPECT_EQ(sceneSession->Snapshot(1.f), nullptr);
1658
1659 sessionInfo.persistentId_ = 2;
1660 EXPECT_EQ(sceneSession->Snapshot(1.f), nullptr);
1661 usleep(WAIT_SYNC_IN_NS);
1662 }
1663
1664 /**
1665 * @tc.name: IsParentSessionVisible
1666 * @tc.desc: IsParentSessionVisible
1667 * @tc.type: FUNC
1668 */
1669 HWTEST_F(SceneSessionManagerTest4, IsParentSessionVisible, TestSize.Level1)
1670 {
1671 ASSERT_NE(ssm_, nullptr);
1672 SessionInfo sessionInfo;
1673 sessionInfo.bundleName_ = "bundleName";
1674 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
1675 ASSERT_NE(sceneSession, nullptr);
1676 ASSERT_NE(sceneSession->property_, nullptr);
1677 sceneSession->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1678 sceneSession->property_->SetParentPersistentId(1);
1679 sceneSession->isVisible_ = false;
1680 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession));
1681 bool result = ssm_->IsParentSessionVisible(sceneSession);
1682 EXPECT_EQ(result, false);
1683
1684 bool testRet = sceneSession->IsScbCoreEnabled();
1685 EXPECT_EQ(testRet, true);
1686
1687 sceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
1688 sceneSession->isVisible_ = true;
1689 sceneSession->SetSessionState(SessionState::STATE_FOREGROUND);
1690 result = ssm_->IsParentSessionVisible(sceneSession);
1691 EXPECT_EQ(result, true);
1692
1693 sceneSession->property_->SetParentPersistentId(2);
1694 sceneSession->SetSessionState(SessionState::STATE_DISCONNECT);
1695 result = ssm_->IsParentSessionVisible(sceneSession);
1696 EXPECT_EQ(result, true);
1697
1698 sceneSession->property_->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
1699 result = ssm_->IsParentSessionVisible(sceneSession);
1700 EXPECT_EQ(result, true);
1701 }
1702
1703 /**
1704 * @tc.name: GetTopFocusableNonAppSession
1705 * @tc.desc: GetTopFocusableNonAppSession
1706 * @tc.type: FUNC
1707 */
1708 HWTEST_F(SceneSessionManagerTest4, GetTopFocusableNonAppSession, TestSize.Level0)
1709 {
1710 ASSERT_NE(ssm_, nullptr);
1711 SessionInfo sessionInfo;
1712 sessionInfo.bundleName_ = "bundleName";
1713 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
1714 ASSERT_NE(sceneSession, nullptr);
1715 ASSERT_NE(sceneSession->property_, nullptr);
1716
1717 sceneSession->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
1718 sceneSession->property_->SetFocusable(true);
1719 sceneSession->isVisible_ = true;
1720 sceneSession->state_ = SessionState::STATE_FOREGROUND;
1721 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession));
1722 sptr<SceneSession> result = ssm_->GetTopFocusableNonAppSession();
1723 EXPECT_EQ(result, sceneSession);
1724
1725 sceneSession->isVisible_ = false;
1726 result = ssm_->GetTopFocusableNonAppSession();
1727 EXPECT_EQ(result, nullptr);
1728
1729 sceneSession->property_->SetFocusable(false);
1730 result = ssm_->GetTopFocusableNonAppSession();
1731 EXPECT_EQ(result, nullptr);
1732
1733 sceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1734 result = ssm_->GetTopFocusableNonAppSession();
1735 EXPECT_EQ(result, nullptr);
1736 }
1737
1738 /**
1739 * @tc.name: GetTopFocusableNonAppSession01
1740 * @tc.desc: GetTopFocusableNonAppSession01
1741 * @tc.type: FUNC
1742 */
1743 HWTEST_F(SceneSessionManagerTest4, GetTopFocusableNonAppSession01, TestSize.Level1)
1744 {
1745 SessionInfo sessionInfo;
1746 sessionInfo.bundleName_ = "bundleName";
1747 sptr<SceneSession> wallpaper = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
1748 wallpaper->property_->SetWindowType(WindowType::WINDOW_TYPE_WALLPAPER);
1749 wallpaper->zOrder_ = 1;
1750 sptr<SceneSession> desktop = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
1751 desktop->property_->SetWindowType(WindowType::WINDOW_TYPE_DESKTOP);
1752 desktop->zOrder_ = 2;
1753 desktop->property_->SetFocusable(true);
1754 desktop->isVisible_ = true;
1755 desktop->state_ = SessionState::STATE_FOREGROUND;
1756
1757 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
1758 sceneSession->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
1759 sceneSession->zOrder_ = 3;
1760 sptr<SceneSession> sceneSession1 = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
1761 sceneSession1->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
1762 sceneSession1->zOrder_ = 0;
1763 ssm_->sceneSessionMap_.insert(std::make_pair(0, sceneSession1));
1764 ssm_->sceneSessionMap_.insert(std::make_pair(1, wallpaper));
1765 ssm_->sceneSessionMap_.insert(std::make_pair(2, desktop));
1766 ssm_->sceneSessionMap_.insert(std::make_pair(3, sceneSession));
1767 sptr<SceneSession> result = ssm_->GetTopFocusableNonAppSession();
1768 EXPECT_EQ(result, desktop);
1769 }
1770
1771 /**
1772 * @tc.name: GetNextFocusableSession
1773 * @tc.desc: GetNextFocusableSession
1774 * @tc.type: FUNC
1775 */
1776 HWTEST_F(SceneSessionManagerTest4, GetNextFocusableSession, TestSize.Level0)
1777 {
1778 ASSERT_NE(ssm_, nullptr);
1779 SessionInfo sessionInfo;
1780 sessionInfo.bundleName_ = "bundleName";
1781 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
1782 sptr<SceneSession> sceneSession02 = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
1783 sptr<SceneSession> sceneSession03 = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
1784 sptr<SceneSession> sceneSession04 = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
1785 sptr<SceneSession> sceneSession05 = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
1786 ASSERT_NE(sceneSession, nullptr);
1787 ASSERT_NE(sceneSession02, nullptr);
1788 ASSERT_NE(sceneSession03, nullptr);
1789 ASSERT_NE(sceneSession04, nullptr);
1790 ASSERT_NE(sceneSession05, nullptr);
1791 ASSERT_NE(sceneSession->property_, nullptr);
1792
1793 sceneSession->SetForceHideState(ForceHideState::NOT_HIDDEN);
1794 sceneSession->property_->SetFocusable(true);
1795 sceneSession->property_->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
1796 sceneSession->isVisible_ = true;
1797 sceneSession->state_ = SessionState::STATE_FOREGROUND;
1798 sceneSession->SetZOrder(1);
1799
1800 sceneSession02->SetFocusable(false);
1801 sceneSession02->SetZOrder(2);
1802
1803 sceneSession03->SetZOrder(3);
1804
1805 sceneSession04->SetForceHideState(ForceHideState::HIDDEN_WHEN_FOCUSED);
1806 sceneSession04->SetZOrder(4);
1807
1808 sceneSession05->persistentId_ = 1;
1809 sceneSession05->SetZOrder(5);
1810
1811 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession));
1812 ssm_->sceneSessionMap_.insert(std::make_pair(2, sceneSession02));
1813 ssm_->sceneSessionMap_.insert(std::make_pair(3, sceneSession03));
1814 ssm_->sceneSessionMap_.insert(std::make_pair(4, sceneSession04));
1815 ssm_->sceneSessionMap_.insert(std::make_pair(5, sceneSession05));
1816 sptr<SceneSession> result = ssm_->GetNextFocusableSession(DEFAULT_DISPLAY_ID, 1);
1817 EXPECT_EQ(result, sceneSession);
1818 }
1819
1820 /**
1821 * @tc.name: GetTopNearestBlockingFocusSession
1822 * @tc.desc: GetTopNearestBlockingFocusSession
1823 * @tc.type: FUNC
1824 */
1825 HWTEST_F(SceneSessionManagerTest4, GetTopNearestBlockingFocusSession, TestSize.Level0)
1826 {
1827 ASSERT_NE(ssm_, nullptr);
1828 SessionInfo sessionInfo;
1829 sessionInfo.bundleName_ = "bundleName";
1830 sessionInfo.isSystem_ = true;
1831 sptr<SceneSession> sceneSession01 = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
1832 sptr<SceneSession> sceneSession02 = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
1833 sptr<SceneSession> sceneSession03 = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
1834 sptr<SceneSession> sceneSession04 = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
1835 sptr<SceneSession> parentSceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
1836 ASSERT_NE(sceneSession01, nullptr);
1837 ASSERT_NE(sceneSession02, nullptr);
1838 ASSERT_NE(sceneSession03, nullptr);
1839 ASSERT_NE(sceneSession04, nullptr);
1840 ASSERT_NE(parentSceneSession, nullptr);
1841
1842 sceneSession01->SetZOrder(1);
1843 sceneSession01->isVisible_ = true;
1844 sceneSession01->SetSessionState(SessionState::STATE_FOREGROUND);
1845
1846 sceneSession02->SetZOrder(2);
1847 sceneSession02->isVisible_ = true;
1848 sceneSession02->SetSessionState(SessionState::STATE_FOREGROUND);
1849 sceneSession02->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1850 sceneSession02->blockingFocus_ = false;
1851
1852 sceneSession03->SetZOrder(3);
1853 sceneSession03->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1854 parentSceneSession->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1855 sceneSession03->property_->SetParentPersistentId(8);
1856
1857 sceneSession04->SetZOrder(4);
1858 sceneSession04->property_->SetParentPersistentId(1);
1859
1860 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession01));
1861 ssm_->sceneSessionMap_.insert(std::make_pair(2, sceneSession02));
1862 ssm_->sceneSessionMap_.insert(std::make_pair(3, sceneSession03));
1863 ssm_->sceneSessionMap_.insert(std::make_pair(4, sceneSession04));
1864 ssm_->sceneSessionMap_.insert(std::make_pair(8, parentSceneSession));
1865
1866 sptr<SceneSession> ret = ssm_->GetTopNearestBlockingFocusSession(DEFAULT_DISPLAY_ID, 0, true);
1867 EXPECT_EQ(ret, sceneSession01);
1868
1869 ret = ssm_->GetTopNearestBlockingFocusSession(DEFAULT_DISPLAY_ID, 10, true);
1870 EXPECT_EQ(ret, nullptr);
1871 }
1872
1873 /**
1874 * @tc.name: GetTopNearestBlockingFocusSession01
1875 * @tc.desc: GetTopNearestBlockingFocusSession01
1876 * @tc.type: FUNC
1877 */
1878 HWTEST_F(SceneSessionManagerTest4, GetTopNearestBlockingFocusSession01, TestSize.Level1)
1879 {
1880 ASSERT_NE(ssm_, nullptr);
1881 SessionInfo sessionInfo;
1882 sessionInfo.bundleName_ = "bundleName";
1883 ssm_->systemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
1884 sptr<SceneSession> sceneSession01 = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
1885 sptr<SceneSession> sceneSession02 = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
1886 sceneSession01->SetZOrder(1);
1887 sceneSession01->persistentId_ = 1;
1888 sceneSession01->isVisible_ = true;
1889 sceneSession01->SetSessionState(SessionState::STATE_FOREGROUND);
1890 sceneSession02->SetZOrder(3);
1891 sceneSession02->isVisible_ = true;
1892 sceneSession02->SetSessionState(SessionState::STATE_FOREGROUND);
1893 sceneSession02->SetParentSession(sceneSession01);
1894 sceneSession02->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1895 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession01));
1896 ssm_->sceneSessionMap_.insert(std::make_pair(2, sceneSession02));
1897 sptr<SceneSession> ret = ssm_->GetTopNearestBlockingFocusSession(DEFAULT_DISPLAY_ID, 0, true);
1898 EXPECT_EQ(ret, sceneSession01);
1899
1900 ssm_->systemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1901 sceneSession02->property_->SetWindowType(WindowType::WINDOW_TYPE_FLOAT);
1902 ret = ssm_->GetTopNearestBlockingFocusSession(DEFAULT_DISPLAY_ID, 2, true);
1903 EXPECT_EQ(ret, nullptr);
1904 }
1905
1906 /**
1907 * @tc.name: CheckBlockingFocus
1908 * @tc.desc: CheckBlockingFocus
1909 * 1.session with blockfocus porperty need be blocked
1910 * 2.main window need be blocked
1911 * 3.WINDOW_TYPE_VOICE_INTERACTION window type need be blocked
1912 * @tc.type: FUNC
1913 */
1914 HWTEST_F(SceneSessionManagerTest4, CheckBlockingFocus, TestSize.Level1)
1915 {
1916 ASSERT_NE(ssm_, nullptr);
1917 SessionInfo sessionInfo;
1918 sessionInfo.bundleName_ = "bundleName";
1919 ssm_->systemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
1920 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
1921 sptr<SceneSession> sceneSession01 = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
1922 bool ret = ssm_->CheckBlockingFocus(sceneSession, false);
1923 EXPECT_EQ(ret, false);
1924
1925 sceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1926 ret = ssm_->CheckBlockingFocus(sceneSession, true);
1927 EXPECT_EQ(ret, true);
1928
1929 sceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_VOICE_INTERACTION);
1930 ret = ssm_->CheckBlockingFocus(sceneSession, false);
1931 EXPECT_EQ(ret, true);
1932
1933 sceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1934 sceneSession->sessionInfo_.isSystem_ = true;
1935 sceneSession->blockingFocus_ = true;
1936 ret = ssm_->CheckBlockingFocus(sceneSession, false);
1937 EXPECT_EQ(ret, true);
1938
1939 ssm_->systemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1940 sceneSession->blockingFocus_ = false;
1941 sceneSession01->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1942 sceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_FLOAT);
1943 sceneSession->SetParentSession(sceneSession01);
1944 ret = ssm_->CheckBlockingFocus(sceneSession, false);
1945 EXPECT_EQ(ret, false);
1946
1947 ssm_->systemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
1948 sceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1949 sceneSession->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1950 ret = ssm_->CheckBlockingFocus(sceneSession, true);
1951 EXPECT_EQ(ret, false);
1952
1953 sceneSession->isMidScene_ = true;
1954 ret = ssm_->CheckBlockingFocus(sceneSession, true);
1955 EXPECT_EQ(ret, true);
1956 sceneSession->isMidScene_ = false;
1957 }
1958
1959 /**
1960 * @tc.name: RequestFocusSpecificCheck
1961 * @tc.desc: RequestFocusSpecificCheck
1962 * @tc.type: FUNC
1963 */
1964 HWTEST_F(SceneSessionManagerTest4, RequestFocusSpecificCheck, TestSize.Level0)
1965 {
1966 ASSERT_NE(ssm_, nullptr);
1967 SessionInfo sessionInfo;
1968 sessionInfo.bundleName_ = "bundleName";
1969 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
1970 ASSERT_NE(sceneSession, nullptr);
1971 bool byForeground = true;
1972 FocusChangeReason reason = FocusChangeReason::CLIENT_REQUEST;
1973 sceneSession->SetForceHideState(ForceHideState::HIDDEN_WHEN_FOCUSED);
1974 WSError result = ssm_->RequestFocusSpecificCheck(DEFAULT_DISPLAY_ID, sceneSession, byForeground, reason);
1975 EXPECT_EQ(result, WSError::WS_ERROR_INVALID_OPERATION);
1976
1977 sceneSession->SetForceHideState(ForceHideState::NOT_HIDDEN);
1978 sptr<SceneSession> sceneSession01 = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
1979 ASSERT_NE(sceneSession01, nullptr);
1980 ssm_->sceneSessionMap_.insert(std::make_pair(0, sceneSession01));
1981 sceneSession01->parentSession_ = sceneSession;
1982 result = ssm_->RequestFocusSpecificCheck(DEFAULT_DISPLAY_ID, sceneSession, byForeground, reason);
1983 EXPECT_EQ(result, WSError::WS_OK);
1984 }
1985
1986 /**
1987 * @tc.name: ProcessModalExtensionPointDown
1988 * @tc.desc: ProcessModalExtensionPointDown
1989 * @tc.type: FUNC
1990 */
1991 HWTEST_F(SceneSessionManagerTest4, ProcessModalExtensionPointDown, TestSize.Level1)
1992 {
1993 ASSERT_NE(ssm_, nullptr);
1994 sptr<IRemoteObject> token = sptr<IRemoteObjectMocker>::MakeSptr();
1995 ASSERT_NE(token, nullptr);
1996 int32_t posX = 1;
1997 int32_t posY = 1;
1998 ExtensionWindowAbilityInfo extensionWindowAbilityInfo;
1999 extensionWindowAbilityInfo.persistentId = 1;
2000 extensionWindowAbilityInfo.parentId = 2;
2001 ssm_->extSessionInfoMap_.insert(std::make_pair(token, extensionWindowAbilityInfo));
2002
2003 SessionInfo sessionInfo;
2004 sessionInfo.bundleName_ = "bundleName";
2005 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
2006 ASSERT_NE(sceneSession, nullptr);
2007 ssm_->sceneSessionMap_.insert(std::make_pair(2, sceneSession));
2008 ssm_->ProcessModalExtensionPointDown(token, posX, posY);
2009
2010 ExtensionWindowEventInfo eventInfo;
2011 eventInfo.pid = 0;
2012 eventInfo.persistentId = 1;
2013 sceneSession->modalUIExtensionInfoList_.push_back(eventInfo);
2014 ssm_->ProcessModalExtensionPointDown(token, posX, posY);
2015
2016 eventInfo.persistentId = 4;
2017 ssm_->ProcessModalExtensionPointDown(token, posX, posY);
2018
2019 eventInfo.pid = 4;
2020 ssm_->ProcessModalExtensionPointDown(token, posX, posY);
2021
2022 sceneSession->modalUIExtensionInfoList_.clear();
2023 ssm_->ProcessModalExtensionPointDown(token, posX, posY);
2024 bool result = true;
2025 EXPECT_EQ(WSError::WS_OK, ssm_->GetFreeMultiWindowEnableState(result));
2026 usleep(WAIT_SYNC_IN_NS);
2027 }
2028 } // namespace
2029 } // namespace Rosen
2030 } // namespace OHOS
2031