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 <gtest/gtest.h>
17
18 #include "common/include/session_permission.h"
19 #include "interfaces/include/ws_common.h"
20 #include "iremote_object_mocker.h"
21 #include "session_manager/include/scene_session_manager.h"
22 #include "session_info.h"
23 #include "session/host/include/scene_session.h"
24 #include "session_manager.h"
25
26 using namespace testing;
27 using namespace testing::ext;
28
29 namespace OHOS {
30 namespace Rosen {
31
32 class SceneSessionManagerTest9 : public testing::Test {
33 public:
34 static void SetUpTestCase();
35 static void TearDownTestCase();
36 void SetUp() override;
37 void TearDown() override;
38
39 static sptr<SceneSessionManager> ssm_;
40
41 private:
42 static constexpr uint32_t WAIT_SYNC_IN_NS = 200000;
43 };
44
45 sptr<SceneSessionManager> SceneSessionManagerTest9::ssm_ = nullptr;
46
NotifyRecoverSceneSessionFuncTest(const sptr<SceneSession> & session,const SessionInfo & sessionInfo)47 void NotifyRecoverSceneSessionFuncTest(const sptr<SceneSession>& session, const SessionInfo& sessionInfo) {}
48
getStateFalse(const ManagerState key)49 bool getStateFalse(const ManagerState key)
50 {
51 return false;
52 }
53
getStateTrue(const ManagerState key)54 bool getStateTrue(const ManagerState key)
55 {
56 return true;
57 }
58
TraverseFuncTest(const sptr<SceneSession> & session)59 bool TraverseFuncTest(const sptr<SceneSession>& session)
60 {
61 return true;
62 }
63
SetUpTestCase()64 void SceneSessionManagerTest9::SetUpTestCase()
65 {
66 ssm_ = &SceneSessionManager::GetInstance();
67 }
68
TearDownTestCase()69 void SceneSessionManagerTest9::TearDownTestCase()
70 {
71 ssm_ = nullptr;
72 }
73
SetUp()74 void SceneSessionManagerTest9::SetUp() {}
75
TearDown()76 void SceneSessionManagerTest9::TearDown()
77 {
78 usleep(WAIT_SYNC_IN_NS);
79 }
80
81 namespace {
82 /**
83 * @tc.name: TraverseSessionTreeFromTopToBottom
84 * @tc.desc: TraverseSessionTreeFromTopToBottom
85 * @tc.type: FUNC
86 */
87 HWTEST_F(SceneSessionManagerTest9, TraverseSessionTreeFromTopToBottom, TestSize.Level1)
88 {
89 ASSERT_NE(nullptr, ssm_);
90 ssm_->TraverseSessionTreeFromTopToBottom(TraverseFuncTest);
91
92 SessionInfo sessionInfo;
93 sessionInfo.bundleName_ = "SceneSessionManagerTest9";
94 sessionInfo.abilityName_ = "TraverseSessionTreeFromTopToBottom";
95 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
96 ASSERT_NE(nullptr, sceneSession);
97 ssm_->sceneSessionMap_.insert(std::make_pair(1, nullptr));
98 ssm_->sceneSessionMap_.insert(std::make_pair(2, sceneSession));
99 ssm_->TraverseSessionTreeFromTopToBottom(TraverseFuncTest);
100 }
101
102 /**
103 * @tc.name: TestRequestFocusStatus_01
104 * @tc.desc: Test RequestFocusStatus with sceneSession is nullptr
105 * @tc.type: FUNC
106 */
107 HWTEST_F(SceneSessionManagerTest9, TestRequestFocusStatus_01, TestSize.Level1)
108 {
109 ASSERT_NE(nullptr, ssm_);
110 auto res = ssm_->RequestFocusStatus(1, false, false, FocusChangeReason::FLOATING_SCENE);
111 ASSERT_EQ(res, WMError::WM_ERROR_NULLPTR);
112 }
113
114 /**
115 * @tc.name: TestRequestFocusStatus_02
116 * @tc.desc: Test RequestFocusStatus with not call by the same process
117 * @tc.type: FUNC
118 */
119 HWTEST_F(SceneSessionManagerTest9, TestRequestFocusStatus_02, TestSize.Level1)
120 {
121 ASSERT_NE(nullptr, ssm_);
122
123 SessionInfo sessionInfo;
124 sessionInfo.bundleName_ = "SceneSessionManagerTest9";
125 sessionInfo.abilityName_ = "RequestFocusStatus02";
126 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
127 sceneSession->SetCallingPid(0);
128 sceneSession->isVisible_ = false;
129 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession));
130 auto res = ssm_->RequestFocusStatus(1, false, false, FocusChangeReason::FLOATING_SCENE);
131 ASSERT_EQ(res, WMError::WM_ERROR_NULLPTR);
132 }
133
134 /**
135 * @tc.name: TestRequestSessionFocusImmediately_01
136 * @tc.desc: Test RequestSessionFocusImmediately with invalid persistentId
137 * @tc.type: FUNC
138 */
139 HWTEST_F(SceneSessionManagerTest9, TestRequestSessionFocusImmediately_01, TestSize.Level1)
140 {
141 ASSERT_NE(nullptr, ssm_);
142 ssm_->sceneSessionMap_.clear();
143
144 WSError ret = ssm_->RequestSessionFocusImmediately(0);
145 EXPECT_EQ(ret, WSError::WS_ERROR_INVALID_SESSION);
146 }
147
148 /**
149 * @tc.name: TestRequestSessionFocusImmediately_02
150 * @tc.desc: Test RequestSessionFocusImmediately with session is nullptr
151 * @tc.type: FUNC
152 */
153 HWTEST_F(SceneSessionManagerTest9, TestRequestSessionFocusImmediately_02, TestSize.Level1)
154 {
155 ASSERT_NE(nullptr, ssm_);
156 ssm_->sceneSessionMap_.clear();
157
158 WSError ret = ssm_->RequestSessionFocusImmediately(2);
159 EXPECT_EQ(ret, WSError::WS_ERROR_INVALID_SESSION);
160 }
161
162 /**
163 * @tc.name: TestRequestSessionFocusImmediately_03
164 * @tc.desc: Test RequestSessionFocusImmediately with session is not focusable
165 * @tc.type: FUNC
166 */
167 HWTEST_F(SceneSessionManagerTest9, TestRequestSessionFocusImmediately_03, TestSize.Level1)
168 {
169 ASSERT_NE(nullptr, ssm_);
170 ssm_->sceneSessionMap_.clear();
171
172 SessionInfo sessionInfo;
173 sessionInfo.bundleName_ = "SceneSessionManagerTest9";
174 sessionInfo.abilityName_ = "RequestSessionFocusImmediately02";
175 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
176 sceneSession->SetFocusable(false);
177 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession));
178
179 auto ret = ssm_->RequestSessionFocusImmediately(1);
180 EXPECT_EQ(ret, WSError::WS_DO_NOTHING);
181 }
182
183 /**
184 * @tc.name: TestRequestSessionFocusImmediately_04
185 * @tc.desc: Test RequestSessionFocusImmediately with session is not focused on show
186 * @tc.type: FUNC
187 */
188 HWTEST_F(SceneSessionManagerTest9, TestRequestSessionFocusImmediately_04, TestSize.Level1)
189 {
190 ASSERT_NE(nullptr, ssm_);
191 ssm_->sceneSessionMap_.clear();
192
193 SessionInfo sessionInfo;
194 sessionInfo.bundleName_ = "SceneSessionManagerTest9";
195 sessionInfo.abilityName_ = "RequestSessionFocusImmediately02";
196 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
197 sceneSession->SetFocusable(true);
198 sceneSession->SetFocusedOnShow(false);
199 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession));
200 auto ret = ssm_->RequestSessionFocusImmediately(1);
201 EXPECT_EQ(ret, WSError::WS_DO_NOTHING);
202 }
203
204 /**
205 * @tc.name: TestRequestSessionFocusImmediately_05
206 * @tc.desc: Test RequestSessionFocusImmediately with ForceHideState HIDDEN_WHEN_FOCUSED
207 * @tc.type: FUNC
208 */
209 HWTEST_F(SceneSessionManagerTest9, TestRequestSessionFocusImmediately_05, TestSize.Level1)
210 {
211 ASSERT_NE(nullptr, ssm_);
212 ssm_->sceneSessionMap_.clear();
213
214 SessionInfo sessionInfo;
215 sessionInfo.bundleName_ = "SceneSessionManagerTest9";
216 sessionInfo.abilityName_ = "RequestSessionFocusImmediately02";
217 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
218 sceneSession->SetFocusable(true);
219 sceneSession->SetFocusedOnShow(true);
220 sceneSession->SetForceHideState(ForceHideState::HIDDEN_WHEN_FOCUSED);
221 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession));
222 auto ret = ssm_->RequestSessionFocusImmediately(1);
223 EXPECT_EQ(ret, WSError::WS_ERROR_INVALID_OPERATION);
224 }
225
226 /**
227 * @tc.name: TestRequestSessionFocusImmediately_06
228 * @tc.desc: Test RequestSessionFocusImmediately with ForceHideState NOT_HIDDEN
229 * @tc.type: FUNC
230 */
231 HWTEST_F(SceneSessionManagerTest9, TestRequestSessionFocusImmediately_06, TestSize.Level1)
232 {
233 ASSERT_NE(nullptr, ssm_);
234 ssm_->sceneSessionMap_.clear();
235
236 SessionInfo sessionInfo;
237 sessionInfo.bundleName_ = "SceneSessionManagerTest9";
238 sessionInfo.abilityName_ = "RequestSessionFocusImmediately02";
239 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
240 sceneSession->SetFocusable(true);
241 sceneSession->SetFocusedOnShow(true);
242 sceneSession->SetForceHideState(ForceHideState::NOT_HIDDEN);
243 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession));
244 WSError ret = ssm_->RequestSessionFocusImmediately(1);
245 EXPECT_EQ(ret, WSError::WS_OK);
246 }
247
248 /**
249 * @tc.name: Test RequestSessionFocus_01
250 * @tc.desc: Test RequestSessionFocus invalid persistentId
251 * @tc.type: FUNC
252 */
253 HWTEST_F(SceneSessionManagerTest9, RequestSessionFocus_01, TestSize.Level1)
254 {
255 ASSERT_NE(nullptr, ssm_);
256 ssm_->sceneSessionMap_.clear();
257
258 WSError ret = ssm_->RequestSessionFocus(0);
259 EXPECT_EQ(ret, WSError::WS_ERROR_INVALID_SESSION);
260 }
261
262 /**
263 * @tc.name: RequestSessionFocus_02
264 * @tc.desc: Test RequestSessionFocus with session is nullptr
265 * @tc.type: FUNC
266 */
267 HWTEST_F(SceneSessionManagerTest9, RequestSessionFocus_02, TestSize.Level1)
268 {
269 ASSERT_NE(nullptr, ssm_);
270 ssm_->sceneSessionMap_.clear();
271
272 WSError ret = ssm_->RequestSessionFocus(2);
273 EXPECT_EQ(ret, WSError::WS_ERROR_INVALID_SESSION);
274 }
275
276 /**
277 * @tc.name: TestRequestSessionFocus_03
278 * @tc.desc: Test RequestSessionFocus with session is not focusable
279 * @tc.type: FUNC
280 */
281 HWTEST_F(SceneSessionManagerTest9, TestRequestSessionFocus_03, TestSize.Level1)
282 {
283 ASSERT_NE(nullptr, ssm_);
284 ssm_->sceneSessionMap_.clear();
285 SessionInfo sessionInfo;
286 sessionInfo.bundleName_ = "SceneSessionManagerTest9";
287 sessionInfo.abilityName_ = "TestRequestSessionFocus_03";
288 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
289 ASSERT_NE(nullptr, sceneSession);
290 sceneSession->SetFocusable(false);
291 sceneSession->UpdateVisibilityInner(true);
292 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession));
293
294 WSError ret = ssm_->RequestSessionFocus(1, false, FocusChangeReason::DEFAULT);
295 ASSERT_EQ(ret, WSError::WS_DO_NOTHING);
296 }
297
298 /**
299 * @tc.name: TestRequestSessionFocus_04
300 * @tc.desc: Test RequestSessionFocus with session is not visible
301 * @tc.type: FUNC
302 */
303 HWTEST_F(SceneSessionManagerTest9, TestRequestSessionFocus_04, TestSize.Level1)
304 {
305 ASSERT_NE(nullptr, ssm_);
306 ssm_->sceneSessionMap_.clear();
307 SessionInfo sessionInfo;
308 sessionInfo.bundleName_ = "SceneSessionManagerTest9";
309 sessionInfo.abilityName_ = "TestRequestSessionFocus_04";
310 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
311 ASSERT_NE(nullptr, sceneSession);
312 sceneSession->SetFocusable(true);
313 sceneSession->UpdateVisibilityInner(false);
314 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession));
315
316 WSError ret = ssm_->RequestSessionFocus(1, false, FocusChangeReason::DEFAULT);
317 ASSERT_EQ(ret, WSError::WS_DO_NOTHING);
318 }
319
320 /**
321 * @tc.name: TestRequestSessionFocus_05
322 * @tc.desc: Test RequestSessionFocus with session is not focused on show
323 * @tc.type: FUNC
324 */
325 HWTEST_F(SceneSessionManagerTest9, TestRequestSessionFocus_05, TestSize.Level1)
326 {
327 ASSERT_NE(nullptr, ssm_);
328 ssm_->sceneSessionMap_.clear();
329 SessionInfo sessionInfo;
330 sessionInfo.bundleName_ = "SceneSessionManagerTest9";
331 sessionInfo.abilityName_ = "TestRequestSessionFocus_05";
332 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
333 ASSERT_NE(nullptr, sceneSession);
334 sceneSession->SetFocusable(true);
335 sceneSession->UpdateVisibilityInner(true);
336 sceneSession->SetSessionState(SessionState::STATE_FOREGROUND);
337 sceneSession->SetFocusedOnShow(false);
338 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession));
339
340 WSError ret = ssm_->RequestSessionFocus(1, false, FocusChangeReason::DEFAULT);
341 ASSERT_EQ(ret, WSError::WS_DO_NOTHING);
342 }
343
344 /**
345 * @tc.name: TestRequestSessionFocus_06
346 * @tc.desc: Test RequestSessionFocus with session is not focusable on show
347 * @tc.type: FUNC
348 */
349 HWTEST_F(SceneSessionManagerTest9, TestRequestSessionFocus_06, TestSize.Level1)
350 {
351 ASSERT_NE(nullptr, ssm_);
352 ssm_->sceneSessionMap_.clear();
353 SessionInfo sessionInfo;
354 sessionInfo.bundleName_ = "SceneSessionManagerTest9";
355 sessionInfo.abilityName_ = "TestRequestSessionFocus_06";
356 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
357 ASSERT_NE(nullptr, sceneSession);
358 sceneSession->SetFocusable(true);
359 sceneSession->UpdateVisibilityInner(true);
360 sceneSession->SetSessionState(SessionState::STATE_FOREGROUND);
361 sceneSession->SetFocusedOnShow(true);
362 sceneSession->SetFocusableOnShow(false);
363 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession));
364
365 WSError ret = ssm_->RequestSessionFocus(1, false, FocusChangeReason::FOREGROUND);
366 ASSERT_EQ(ret, WSError::WS_DO_NOTHING);
367 }
368
369 /**
370 * @tc.name: TestRequestSessionFocus_07
371 * @tc.desc: Test RequestSessionFocus with windowType is APP_SUB_WINDOW_BASE
372 * @tc.type: FUNC
373 */
374 HWTEST_F(SceneSessionManagerTest9, TestRequestSessionFocus_07, TestSize.Level1)
375 {
376 ASSERT_NE(nullptr, ssm_);
377 ssm_->sceneSessionMap_.clear();
378 SessionInfo sessionInfo;
379 sessionInfo.bundleName_ = "SceneSessionManagerTest9";
380 sessionInfo.abilityName_ = "TestRequestSessionFocus_07";
381 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
382 ASSERT_NE(nullptr, sceneSession);
383 sceneSession->SetFocusable(true);
384 sceneSession->UpdateVisibilityInner(true);
385 sceneSession->SetFocusedOnShow(true);
386 sceneSession->SetFocusableOnShow(true);
387 sceneSession->GetSessionProperty()->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
388 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession));
389
390 WSError ret = ssm_->RequestSessionFocus(1, false, FocusChangeReason::DEFAULT);
391 ASSERT_EQ(ret, WSError::WS_DO_NOTHING);
392 }
393
394 /**
395 * @tc.name: TestRequestSessionFocus_08
396 * @tc.desc: Test RequestSessionFocus with windowType is WINDOW_TYPE_DIALOG
397 * @tc.type: FUNC
398 */
399 HWTEST_F(SceneSessionManagerTest9, TestRequestSessionFocus_08, TestSize.Level1)
400 {
401 ASSERT_NE(nullptr, ssm_);
402 ssm_->sceneSessionMap_.clear();
403 SessionInfo sessionInfo;
404 sessionInfo.bundleName_ = "SceneSessionManagerTest9";
405 sessionInfo.abilityName_ = "TestRequestSessionFocus_08";
406 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
407 ASSERT_NE(nullptr, sceneSession);
408 sceneSession->SetFocusable(true);
409 sceneSession->UpdateVisibilityInner(true);
410 sceneSession->SetFocusedOnShow(true);
411 sceneSession->SetFocusableOnShow(true);
412 sceneSession->GetSessionProperty()->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
413 sceneSession->SetSessionState(SessionState::STATE_FOREGROUND);
414 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession));
415
416 WSError ret = ssm_->RequestSessionFocus(1, false, FocusChangeReason::DEFAULT);
417 ASSERT_EQ(ret, WSError::WS_OK);
418 }
419
420 /**
421 * @tc.name: TestRequestSessionFocus_09
422 * @tc.desc: Test RequestSessionFocus with ForceHideState HIDDEN_WHEN_FOCUSED
423 * @tc.type: FUNC
424 */
425 HWTEST_F(SceneSessionManagerTest9, TestRequestSessionFocus_09, TestSize.Level1)
426 {
427 ASSERT_NE(nullptr, ssm_);
428 ssm_->sceneSessionMap_.clear();
429 SessionInfo sessionInfo;
430 sessionInfo.bundleName_ = "SceneSessionManagerTest9";
431 sessionInfo.abilityName_ = "TestRequestSessionFocus_08";
432 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
433 ASSERT_NE(nullptr, sceneSession);
434 sceneSession->SetFocusable(true);
435 sceneSession->UpdateVisibilityInner(true);
436 sceneSession->SetFocusedOnShow(true);
437 sceneSession->SetFocusableOnShow(true);
438 sceneSession->GetSessionProperty()->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
439 sceneSession->SetSessionState(SessionState::STATE_FOREGROUND);
440 sceneSession->SetForceHideState(ForceHideState::HIDDEN_WHEN_FOCUSED);
441 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession));
442
443 WSError ret = ssm_->RequestSessionFocus(1, false, FocusChangeReason::DEFAULT);
444 ASSERT_EQ(ret, WSError::WS_ERROR_INVALID_OPERATION);
445 }
446
447 /**
448 * @tc.name: TestRequestSessionFocus_10
449 * @tc.desc: Test RequestSessionFocus with ForceHideState HIDDEN_WHEN_FOCUSED
450 * @tc.type: FUNC
451 */
452 HWTEST_F(SceneSessionManagerTest9, TestRequestSessionFocus_10, TestSize.Level1)
453 {
454 ASSERT_NE(nullptr, ssm_);
455 ssm_->sceneSessionMap_.clear();
456 SessionInfo sessionInfo;
457 sessionInfo.bundleName_ = "SceneSessionManagerTest9";
458 sessionInfo.abilityName_ = "TestRequestSessionFocus_10";
459 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
460 ASSERT_NE(nullptr, sceneSession);
461 sceneSession->SetFocusable(true);
462 sceneSession->UpdateVisibilityInner(true);
463 sceneSession->SetSessionState(SessionState::STATE_FOREGROUND);
464 sceneSession->SetFocusedOnShow(true);
465 sceneSession->SetFocusableOnShow(false);
466 sceneSession->GetSessionProperty()->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
467 sceneSession->SetForceHideState(ForceHideState::NOT_HIDDEN);
468 sceneSession->SetTopmost(true);
469 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession));
470
471 WSError ret = ssm_->RequestSessionFocus(1, false, FocusChangeReason::DEFAULT);
472 ASSERT_EQ(ret, WSError::WS_OK);
473 ASSERT_EQ(sceneSession->isFocused_, true);
474 }
475
476 /**
477 * @tc.name: TestRequestSessionFocus_11
478 * @tc.desc: Test RequestSessionFocus with focusGroup is nullptr
479 * @tc.type: FUNC
480 */
481 HWTEST_F(SceneSessionManagerTest9, TestRequestSessionFocus_11, TestSize.Level1)
482 {
483 ASSERT_NE(nullptr, ssm_);
484 ssm_->sceneSessionMap_.clear();
485 SessionInfo sessionInfo;
486 sessionInfo.bundleName_ = "SceneSessionManagerTest9";
487 sessionInfo.abilityName_ = "TestRequestSessionFocus_11";
488 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
489 sceneSession->property_->SetDisplayId(-1);
490 sceneSession->persistentId_ = 1;
491 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession));
492 WSError ret = ssm_->RequestSessionFocus(1, false, FocusChangeReason::DEFAULT);
493 EXPECT_EQ(ret, WSError::WS_ERROR_NULLPTR);
494 }
495
496 /**
497 * @tc.name: TestRequestSessionFocus_12
498 * @tc.desc: Test RequestSessionFocus with REQUEST_WITH_CHECK_SUB_WINDOW
499 * @tc.type: FUNC
500 */
501 HWTEST_F(SceneSessionManagerTest9, TestRequestSessionFocus_12, TestSize.Level1)
502 {
503 ASSERT_NE(nullptr, ssm_);
504 ssm_->sceneSessionMap_.clear();
505 SessionInfo sessionInfo;
506 sessionInfo.bundleName_ = "SceneSessionManagerTest9";
507 sessionInfo.abilityName_ = "TestRequestSessionFocus_12";
508 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
509 sceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
510 sceneSession->persistentId_ = 1;
511
512 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession));
513 WSError ret = ssm_->RequestSessionFocus(1, false, FocusChangeReason::REQUEST_WITH_CHECK_SUB_WINDOW);
514 EXPECT_EQ(ret, WSError::WS_DO_NOTHING);
515 }
516
517 /**
518 * @tc.name: TestRequestSessionFocus_13
519 * @tc.desc: Test RequestSessionFocus with REQUEST_WITH_CHECK_SUB_WINDOW
520 * @tc.type: FUNC
521 */
522 HWTEST_F(SceneSessionManagerTest9, TestRequestSessionFocus_13, TestSize.Level1)
523 {
524 ASSERT_NE(nullptr, ssm_);
525 ssm_->sceneSessionMap_.clear();
526 SessionInfo sessionInfo;
527 sessionInfo.bundleName_ = "SceneSessionManagerTest9";
528 sessionInfo.abilityName_ = "TestRequestSessionFocus_13";
529 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
530 sceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
531 sceneSession->persistentId_ = 1;
532
533 SessionInfo subSessionInfo;
534 sptr<SceneSession> subSession = sptr<SceneSession>::MakeSptr(subSessionInfo, nullptr);
535 subSession->persistentId_ = 2;
536 subSession->SetFocusable(true);
537 subSession->UpdateVisibilityInner(true);
538 subSession->SetSessionState(SessionState::STATE_FOREGROUND);
539 sceneSession->subSession_.push_back(subSession);
540
541 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession));
542 ssm_->sceneSessionMap_.insert(std::make_pair(2, subSession));
543 ssm_->windowFocusController_->UpdateFocusedSessionId(DEFAULT_DISPLAY_ID, 2);
544 WSError ret = ssm_->RequestSessionFocus(1, false, FocusChangeReason::REQUEST_WITH_CHECK_SUB_WINDOW);
545 EXPECT_EQ(ret, WSError::WS_DO_NOTHING);
546 }
547
548 /**
549 * @tc.name: TestRequestSessionFocus_14
550 * @tc.desc: Test RequestSessionFocus with windowType is APP_SUB_WINDOW_BASE and parent is not visible
551 * @tc.type: FUNC
552 */
553 HWTEST_F(SceneSessionManagerTest9, TestRequestSessionFocus_14, TestSize.Level1)
554 {
555 ASSERT_NE(nullptr, ssm_);
556 ssm_->sceneSessionMap_.clear();
557 SessionInfo sessionInfo;
558 sessionInfo.bundleName_ = "SceneSessionManagerTest9";
559 sessionInfo.abilityName_ = "TestRequestSessionFocus_14";
560 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
561 sceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
562 sceneSession->persistentId_ = 1;
563
564 SessionInfo subSessionInfo;
565 sptr<SceneSession> subSession = sptr<SceneSession>::MakeSptr(subSessionInfo, nullptr);
566 subSession->persistentId_ = 2;
567 subSession->SetFocusable(true);
568 subSession->UpdateVisibilityInner(true);
569 subSession->SetSessionState(SessionState::STATE_FOREGROUND);
570 subSession->SetFocusedOnShow(true);
571 subSession->SetFocusableOnShow(true);
572 subSession->property_->SetParentPersistentId(1);
573 subSession->GetSessionProperty()->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
574
575 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession));
576 ssm_->sceneSessionMap_.insert(std::make_pair(2, subSession));
577 ssm_->windowFocusController_->UpdateFocusedSessionId(DEFAULT_DISPLAY_ID, 0);
578 WSError ret = ssm_->RequestSessionFocus(2, false, FocusChangeReason::DEFAULT);
579 EXPECT_EQ(ret, WSError::WS_DO_NOTHING);
580 }
581
582 /**
583 * @tc.name: RequestSessionUnfocus02
584 * @tc.desc: RequestSessionUnfocus
585 * @tc.type: FUNC
586 */
587 HWTEST_F(SceneSessionManagerTest9, RequestSessionUnfocus02, TestSize.Level0)
588 {
589 ASSERT_NE(nullptr, ssm_);
590 ssm_->sceneSessionMap_.clear();
591 WSError ret = ssm_->RequestSessionUnfocus(0, FocusChangeReason::DEFAULT);
592 ASSERT_EQ(ret, WSError::WS_ERROR_INVALID_SESSION);
593
594 SessionInfo sessionInfo;
595 sessionInfo.bundleName_ = "SceneSessionManagerTest9";
596 sessionInfo.abilityName_ = "RequestSessionUnfocus02";
597 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
598 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession));
599 ssm_->windowFocusController_->UpdateFocusedSessionId(DEFAULT_DISPLAY_ID, 0);
600 ret = ssm_->RequestSessionUnfocus(1, FocusChangeReason::DEFAULT);
601 ASSERT_EQ(ret, WSError::WS_DO_NOTHING);
602 ssm_->windowFocusController_->UpdateFocusedSessionId(DEFAULT_DISPLAY_ID, 2);
603 sceneSession->persistentId_ = 1;
604 sceneSession->SetZOrder(50);
605 sceneSession->state_ = SessionState::STATE_FOREGROUND;
606 sceneSession->isVisible_ = true;
607 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession));
608
609 SessionInfo sessionInfo1;
610 sptr<SceneSession> sceneSession1 = sptr<SceneSession>::MakeSptr(sessionInfo1, nullptr);
611 ASSERT_NE(nullptr, sceneSession1);
612 sceneSession1->GetSessionProperty()->SetParentPersistentId(1);
613 sceneSession1->persistentId_ = 2;
614 sceneSession1->SetZOrder(100);
615 ssm_->sceneSessionMap_.insert(std::make_pair(2, sceneSession1));
616 ret = ssm_->RequestSessionUnfocus(2, FocusChangeReason::DEFAULT);
617 ASSERT_EQ(ret, WSError::WS_OK);
618 auto focusGroup = ssm_->windowFocusController_->GetFocusGroup(DEFAULT_DISPLAY_ID);
619 ASSERT_EQ(focusGroup->GetFocusedSessionId(), 1);
620
621 focusGroup->SetLastFocusedSessionId(4);
622 sceneSession1->GetSessionProperty()->SetWindowType(WindowType::WINDOW_TYPE_SYSTEM_FLOAT);
623 SessionInfo sessionInfo2;
624 sptr<SceneSession> sceneSession2 = sptr<SceneSession>::MakeSptr(sessionInfo2, nullptr);
625 ASSERT_NE(nullptr, sceneSession2);
626 sceneSession2->GetSessionProperty()->SetWindowType(WindowType::WINDOW_TYPE_DESKTOP);
627 sceneSession2->SetZOrder(20);
628 sceneSession2->state_ = SessionState::STATE_FOREGROUND;
629 sceneSession2->isVisible_ = true;
630 sceneSession2->persistentId_ = 4;
631 ssm_->sceneSessionMap_.insert(std::make_pair(4, sceneSession2));
632 ret = ssm_->RequestSessionUnfocus(1, FocusChangeReason::DEFAULT);
633 ASSERT_EQ(ret, WSError::WS_OK);
634 ASSERT_EQ(focusGroup->GetFocusedSessionId(), 4);
635 }
636
637 /**
638 * @tc.name: RequestAllAppSessionUnfocusInner
639 * @tc.desc: RequestAllAppSessionUnfocusInner
640 * @tc.type: FUNC
641 */
642 HWTEST_F(SceneSessionManagerTest9, RequestAllAppSessionUnfocusInner, TestSize.Level1)
643 {
644 ASSERT_NE(nullptr, ssm_);
645 ssm_->RequestAllAppSessionUnfocusInner();
646
647 SessionInfo sessionInfo;
648 sessionInfo.bundleName_ = "SceneSessionManagerTest9";
649 sessionInfo.abilityName_ = "RequestAllAppSessionUnfocusInner";
650 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
651 ASSERT_NE(nullptr, sceneSession);
652 sceneSession->GetSessionProperty()->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
653 auto focusGroup = ssm_->windowFocusController_->GetFocusGroup(DEFAULT_DISPLAY_ID);
654 focusGroup->SetFocusedSessionId(1);
655 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession));
656 ssm_->RequestAllAppSessionUnfocusInner();
657
658 sceneSession->GetSessionProperty()->SetWindowType(WindowType::WINDOW_TYPE_SYSTEM_FLOAT);
659 ssm_->RequestAllAppSessionUnfocusInner();
660 }
661
662 /**
663 * @tc.name: UpdateFocus04
664 * @tc.desc: UpdateFocus
665 * @tc.type: FUNC
666 */
667 HWTEST_F(SceneSessionManagerTest9, UpdateFocus04, TestSize.Level1)
668 {
669 ASSERT_NE(nullptr, ssm_);
670 SessionInfo sessionInfo;
671 sessionInfo.bundleName_ = "SceneSessionManagerTest9";
672 sessionInfo.abilityName_ = "UpdateFocus04";
673 sessionInfo.isSystem_ = true;
674 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
675 ASSERT_NE(nullptr, sceneSession);
676 sceneSession->GetSessionProperty()->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
677 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession));
678 auto focusGroup = ssm_->windowFocusController_->GetFocusGroup(DEFAULT_DISPLAY_ID);
679 focusGroup->SetFocusedSessionId(0);
680 sceneSession->UpdateFocus(false);
681 ssm_->UpdateFocus(1, false);
682
683 ssm_->listenerController_ = nullptr;
684 ssm_->UpdateFocus(1, true);
685
686 std::shared_ptr<SessionListenerController> listenerController = std::make_shared<SessionListenerController>();
687 ssm_->listenerController_ = listenerController;
688 ssm_->UpdateFocus(1, true);
689
690 sessionInfo.isSystem_ = false;
691 focusGroup->SetFocusedSessionId(1);
692 sceneSession->UpdateFocus(true);
693 ssm_->UpdateFocus(1, false);
694
695 sceneSession->UpdateFocus(false);
696 ssm_->UpdateFocus(1, true);
697 }
698
699 /**
700 * @tc.name: ProcessFocusWhenForeground
701 * @tc.desc: ProcessFocusWhenForeground
702 * @tc.type: FUNC
703 */
704 HWTEST_F(SceneSessionManagerTest9, ProcessFocusWhenForeground, TestSize.Level1)
705 {
706 ASSERT_NE(nullptr, ssm_);
707 SessionInfo sessionInfo;
708 sessionInfo.bundleName_ = "SceneSessionManagerTest9";
709 sessionInfo.abilityName_ = "ProcessFocusWhenForeground";
710 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
711 ASSERT_NE(nullptr, sceneSession);
712 sceneSession->persistentId_ = 1;
713 ASSERT_NE(nullptr, sceneSession->property_);
714 sceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
715 auto focusGroup = ssm_->windowFocusController_->GetFocusGroup(DEFAULT_DISPLAY_ID);
716 focusGroup->SetFocusedSessionId(1);
717 ssm_->needBlockNotifyFocusStatusUntilForeground_ = false;
718 ssm_->ProcessFocusWhenForeground(sceneSession);
719
720 sceneSession->isVisible_ = true;
721 sceneSession->SetSessionState(SessionState::STATE_FOREGROUND);
722 ssm_->ProcessFocusWhenForeground(sceneSession);
723 }
724
725 /**
726 * @tc.name: ProcessFocusWhenForeground01
727 * @tc.desc: ProcessFocusWhenForeground
728 * @tc.type: FUNC
729 */
730 HWTEST_F(SceneSessionManagerTest9, ProcessFocusWhenForeground01, TestSize.Level1)
731 {
732 ASSERT_NE(nullptr, ssm_);
733 SessionInfo sessionInfo;
734 sessionInfo.bundleName_ = "SceneSessionManagerTest9";
735 sessionInfo.abilityName_ = "ProcessFocusWhenForeground";
736 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
737 sceneSession->persistentId_ = 1;
738 auto focusGroup = ssm_->windowFocusController_->GetFocusGroup(DEFAULT_DISPLAY_ID);
739 focusGroup->SetFocusedSessionId(2);
740 sceneSession->SetFocusedOnShow(false);
741 ssm_->ProcessFocusWhenForeground(sceneSession);
742 EXPECT_EQ(sceneSession->IsFocusedOnShow(), false);
743
744 sceneSession->isVisible_ = true;
745 sceneSession->SetSessionState(SessionState::STATE_FOREGROUND);
746 ssm_->ProcessFocusWhenForeground(sceneSession);
747 EXPECT_EQ(sceneSession->IsFocusedOnShow(), true);
748 }
749
750 /**
751 * @tc.name: ProcessSubSessionForeground03
752 * @tc.desc: ProcessSubSessionForeground
753 * @tc.type: FUNC
754 */
755 HWTEST_F(SceneSessionManagerTest9, ProcessSubSessionForeground03, TestSize.Level1)
756 {
757 ASSERT_NE(nullptr, ssm_);
758 SessionInfo sessionInfo;
759 sessionInfo.bundleName_ = "SceneSessionManagerTest9";
760 sessionInfo.abilityName_ = "ProcessSubSessionForeground03";
761 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
762 ASSERT_NE(nullptr, sceneSession);
763
764 SessionInfo subSessionInfo;
765 sptr<SceneSession> subSceneSession = sptr<SceneSession>::MakeSptr(subSessionInfo, nullptr);
766 ASSERT_NE(nullptr, subSceneSession);
767 subSceneSession->SetTopmost(true);
768 subSceneSession->SetSessionState(SessionState::STATE_FOREGROUND);
769 subSceneSession->persistentId_ = 1;
770 sceneSession->GetSubSession().push_back(subSceneSession);
771 ssm_->sceneSessionMap_.insert(std::make_pair(1, subSceneSession));
772
773 auto focusGroup = ssm_->windowFocusController_->GetFocusGroup(DEFAULT_DISPLAY_ID);
774 focusGroup->SetFocusedSessionId(1);
775 ssm_->needBlockNotifyFocusStatusUntilForeground_ = true;
776
777 SessionInfo subSessionInfo1;
778 sptr<SceneSession> subSceneSession1 = sptr<SceneSession>::MakeSptr(subSessionInfo1, nullptr);
779 ASSERT_NE(nullptr, subSceneSession1);
780 subSceneSession1->SetTopmost(true);
781 subSceneSession1->SetSessionState(SessionState::STATE_ACTIVE);
782 subSceneSession1->persistentId_ = 0;
783 sceneSession->GetSubSession().push_back(subSceneSession1);
784
785 SessionInfo subSessionInfo2;
786 sptr<SceneSession> subSceneSession2 = sptr<SceneSession>::MakeSptr(subSessionInfo2, nullptr);
787 ASSERT_NE(nullptr, subSceneSession2);
788 subSceneSession2->SetTopmost(true);
789 subSceneSession2->SetSessionState(SessionState::STATE_CONNECT);
790 sceneSession->GetSubSession().push_back(subSceneSession2);
791
792 SessionInfo subSessionInfo3;
793 sptr<SceneSession> subSceneSession3 = sptr<SceneSession>::MakeSptr(subSessionInfo3, nullptr);
794 ASSERT_NE(nullptr, subSceneSession3);
795 subSceneSession3->SetTopmost(false);
796 subSceneSession3->SetSessionState(SessionState::STATE_ACTIVE);
797 sceneSession->GetSubSession().push_back(subSceneSession3);
798
799 sceneSession->GetSubSession().push_back(nullptr);
800
801 ssm_->ProcessSubSessionForeground(sceneSession);
802
803 ssm_->needBlockNotifyFocusStatusUntilForeground_ = false;
804 ssm_->ProcessSubSessionForeground(sceneSession);
805
806 focusGroup->SetFocusedSessionId(2);
807 ssm_->ProcessSubSessionForeground(sceneSession);
808 }
809
810 /**
811 * @tc.name: ProcessFocusWhenForegroundScbCore
812 * @tc.desc: ProcessFocusWhenForegroundScbCore
813 * @tc.type: FUNC
814 */
815 HWTEST_F(SceneSessionManagerTest9, ProcessFocusWhenForegroundScbCore, TestSize.Level1)
816 {
817 ASSERT_NE(nullptr, ssm_);
818 auto focusGroup = ssm_->windowFocusController_->GetFocusGroup(DEFAULT_DISPLAY_ID);
819 focusGroup->SetFocusedSessionId(0);
820 SessionInfo sessionInfo;
821 sessionInfo.bundleName_ = "SceneSessionManagerTest9";
822 sessionInfo.abilityName_ = "ProcessFocusWhenForegroundScbCore";
823 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
824 sceneSession->persistentId_ = 1;
825 ASSERT_NE(nullptr, sceneSession->property_);
826 sceneSession->SetFocusableOnShow(false);
827 sceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
828 ssm_->ProcessFocusWhenForegroundScbCore(sceneSession);
829 ASSERT_EQ(sceneSession->GetPostProcessFocusState().isFocused_, false);
830 ASSERT_EQ(focusGroup->GetFocusedSessionId(), 0);
831
832 sceneSession->SetFocusableOnShow(true);
833 ssm_->ProcessFocusWhenForegroundScbCore(sceneSession); // SetPostProcessFocusState
834 ASSERT_EQ(sceneSession->GetPostProcessFocusState().isFocused_, true);
835
836 sceneSession->isVisible_ = true;
837 sceneSession->SetSessionState(SessionState::STATE_FOREGROUND);
838 ssm_->ProcessFocusWhenForegroundScbCore(sceneSession); // RequestSessionFocus
839 ASSERT_EQ(focusGroup->GetFocusedSessionId(), 1);
840 }
841
842 /**
843 * @tc.name: ProcessModalTopmostRequestFocusImmediately02
844 * @tc.desc: ProcessModalTopmostRequestFocusImmediately
845 * @tc.type: FUNC
846 */
847 HWTEST_F(SceneSessionManagerTest9, ProcessModalTopmostRequestFocusImmediately02, TestSize.Level1)
848 {
849 ASSERT_NE(nullptr, ssm_);
850 SessionInfo sessionInfo;
851 sessionInfo.bundleName_ = "SceneSessionManagerTest9";
852 sessionInfo.abilityName_ = "ProcessModalTopmostRequestFocusImmediately02";
853 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
854 ASSERT_NE(nullptr, sceneSession);
855
856 SessionInfo subSessionInfo;
857 sptr<SceneSession> subSceneSession = sptr<SceneSession>::MakeSptr(subSessionInfo, nullptr);
858 ASSERT_NE(nullptr, subSceneSession);
859 subSceneSession->SetTopmost(true);
860 subSceneSession->SetSessionState(SessionState::STATE_FOREGROUND);
861 subSceneSession->persistentId_ = 1;
862 subSceneSession->SetFocusable(true);
863 subSceneSession->SetFocusedOnShow(true);
864 sceneSession->GetSubSession().push_back(subSceneSession);
865
866 ssm_->sceneSessionMap_.insert(std::make_pair(1, subSceneSession));
867 auto focusGroup = ssm_->windowFocusController_->GetFocusGroup(DEFAULT_DISPLAY_ID);
868 focusGroup->SetFocusedSessionId(1);
869 ssm_->needBlockNotifyFocusStatusUntilForeground_ = true;
870
871 SessionInfo subSessionInfo1;
872 sptr<SceneSession> subSceneSession1 = sptr<SceneSession>::MakeSptr(subSessionInfo1, nullptr);
873 ASSERT_NE(nullptr, subSceneSession1);
874 subSceneSession1->SetTopmost(true);
875 subSceneSession1->SetSessionState(SessionState::STATE_ACTIVE);
876 subSceneSession1->persistentId_ = 0;
877 sceneSession->GetSubSession().push_back(subSceneSession1);
878
879 SessionInfo subSessionInfo2;
880 sptr<SceneSession> subSceneSession2 = sptr<SceneSession>::MakeSptr(subSessionInfo2, nullptr);
881 ASSERT_NE(nullptr, subSceneSession2);
882 subSceneSession2->SetTopmost(true);
883 subSceneSession2->SetSessionState(SessionState::STATE_CONNECT);
884 sceneSession->GetSubSession().push_back(subSceneSession2);
885
886 SessionInfo subSessionInfo3;
887 sptr<SceneSession> subSceneSession3 = sptr<SceneSession>::MakeSptr(subSessionInfo3, nullptr);
888 ASSERT_NE(nullptr, subSceneSession3);
889 subSceneSession3->SetTopmost(false);
890 subSceneSession3->SetSessionState(SessionState::STATE_ACTIVE);
891 sceneSession->GetSubSession().push_back(subSceneSession3);
892
893 sceneSession->GetSubSession().push_back(nullptr);
894
895 WSError ret = ssm_->ProcessModalTopmostRequestFocusImmediately(sceneSession);
896 ASSERT_NE(ret, WSError::WS_OK);
897
898 ssm_->needBlockNotifyFocusStatusUntilForeground_ = false;
899 ssm_->ProcessSubSessionForeground(sceneSession);
900
901 subSceneSession->persistentId_ = 0;
902 ret = ssm_->ProcessModalTopmostRequestFocusImmediately(sceneSession);
903 ASSERT_NE(ret, WSError::WS_OK);
904 }
905
906 /**
907 * @tc.name: ProcessDialogRequestFocusImmediately02
908 * @tc.desc: ProcessDialogRequestFocusImmediately
909 * @tc.type: FUNC
910 */
911 HWTEST_F(SceneSessionManagerTest9, ProcessDialogRequestFocusImmediately02, TestSize.Level1)
912 {
913 ASSERT_NE(nullptr, ssm_);
914 SessionInfo sessionInfo;
915 sessionInfo.bundleName_ = "SceneSessionManagerTest9";
916 sessionInfo.abilityName_ = "ProcessDialogRequestFocusImmediately02";
917 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
918 ASSERT_NE(nullptr, sceneSession);
919 sceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
920
921 SessionInfo dialogSessionInfo;
922 sptr<SceneSession> dialogSceneSession = sptr<SceneSession>::MakeSptr(dialogSessionInfo, nullptr);
923 ASSERT_NE(nullptr, dialogSceneSession);
924 dialogSceneSession->SetTopmost(true);
925 dialogSceneSession->SetSessionState(SessionState::STATE_FOREGROUND);
926 dialogSceneSession->persistentId_ = 1;
927 dialogSceneSession->SetFocusable(true);
928 dialogSceneSession->SetFocusedOnShow(true);
929 sceneSession->GetDialogVector().push_back(dialogSceneSession);
930
931 ssm_->sceneSessionMap_.insert(std::make_pair(1, dialogSceneSession));
932 auto focusGroup = ssm_->windowFocusController_->GetFocusGroup(DEFAULT_DISPLAY_ID);
933 focusGroup->SetFocusedSessionId(1);
934 ssm_->needBlockNotifyFocusStatusUntilForeground_ = true;
935
936 SessionInfo dialogSessionInfo1;
937 sptr<SceneSession> dialogSceneSession1 = sptr<SceneSession>::MakeSptr(dialogSessionInfo1, nullptr);
938 ASSERT_NE(nullptr, dialogSceneSession1);
939 dialogSceneSession1->SetTopmost(true);
940 dialogSceneSession1->SetSessionState(SessionState::STATE_ACTIVE);
941 dialogSceneSession1->persistentId_ = 0;
942 sceneSession->GetDialogVector().push_back(dialogSceneSession1);
943
944 SessionInfo dialogSessionInfo2;
945 sptr<SceneSession> dialogSceneSession2 = sptr<SceneSession>::MakeSptr(dialogSessionInfo2, nullptr);
946 ASSERT_NE(nullptr, dialogSceneSession2);
947 dialogSceneSession2->SetTopmost(true);
948 dialogSceneSession2->SetSessionState(SessionState::STATE_CONNECT);
949 sceneSession->GetDialogVector().push_back(dialogSceneSession2);
950
951 sceneSession->GetDialogVector().push_back(nullptr);
952
953 WSError ret = ssm_->ProcessDialogRequestFocusImmediately(sceneSession);
954 ASSERT_NE(ret, WSError::WS_OK);
955
956 dialogSceneSession->persistentId_ = 0;
957 ret = ssm_->ProcessDialogRequestFocusImmediately(sceneSession);
958 ASSERT_NE(ret, WSError::WS_OK);
959 }
960
961 /**
962 * @tc.name: ProcessSubWindowRequestFocusImmediately1
963 * @tc.desc: Test sceneSession is nullptr
964 * @tc.type: FUNC
965 */
966 HWTEST_F(SceneSessionManagerTest9, ProcessSubWindowRequestFocusImmediately1, TestSize.Level1)
967 {
968 ASSERT_NE(nullptr, ssm_);
969 ssm_->sceneSessionMap_.clear();
970 sptr<SceneSession> sceneSession = nullptr;
971 WSError ret = ssm_->ProcessSubWindowRequestFocusImmediately(sceneSession);
972 EXPECT_EQ(ret, WSError::WS_DO_NOTHING);
973 }
974
975 /**
976 * @tc.name: ProcessSubWindowRequestFocusImmediately2
977 * @tc.desc: Test subSession list is empty
978 * @tc.type: FUNC
979 */
980 HWTEST_F(SceneSessionManagerTest9, ProcessSubWindowRequestFocusImmediately2, TestSize.Level1)
981 {
982 ASSERT_NE(nullptr, ssm_);
983 ssm_->sceneSessionMap_.clear();
984 SessionInfo sessionInfo;
985 sessionInfo.bundleName_ = "SceneSessionManagerTest9";
986 sessionInfo.abilityName_ = "ProcessSubWindowRequestFocusImmediately2";
987 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
988 WSError ret = ssm_->ProcessSubWindowRequestFocusImmediately(sceneSession);
989 EXPECT_EQ(ret, WSError::WS_DO_NOTHING);
990 }
991
992 /**
993 * @tc.name: ProcessSubWindowRequestFocusImmediately3
994 * @tc.desc: Test sub session is focused
995 * @tc.type: FUNC
996 */
997 HWTEST_F(SceneSessionManagerTest9, ProcessSubWindowRequestFocusImmediately3, TestSize.Level1)
998 {
999 ASSERT_NE(nullptr, ssm_);
1000 ssm_->sceneSessionMap_.clear();
1001 SessionInfo sessionInfo;
1002 sessionInfo.bundleName_ = "SceneSessionManagerTest9";
1003 sessionInfo.abilityName_ = "ProcessSubWindowRequestFocusImmediately3";
1004 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
1005 sceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1006 sceneSession->persistentId_ = 1;
1007
1008 SessionInfo subSessionInfo;
1009 sptr<SceneSession> subSession = sptr<SceneSession>::MakeSptr(subSessionInfo, nullptr);
1010 subSession->persistentId_ = 2;
1011 subSession->SetFocusable(true);
1012 subSession->SetFocusedOnShow(true);
1013 sceneSession->subSession_.push_back(subSession);
1014
1015 sceneSession->subSession_.push_back(nullptr);
1016
1017 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession));
1018 ssm_->sceneSessionMap_.insert(std::make_pair(2, subSession));
1019
1020 ssm_->windowFocusController_->UpdateFocusedSessionId(DEFAULT_DISPLAY_ID, 2);
1021 WSError ret = ssm_->ProcessSubWindowRequestFocusImmediately(sceneSession);
1022 EXPECT_EQ(ret, WSError::WS_OK);
1023 }
1024
1025 /**
1026 * @tc.name: ProcessSubWindowRequestFocusImmediately4
1027 * @tc.desc: Test sub session is not visible
1028 * @tc.type: FUNC
1029 */
1030 HWTEST_F(SceneSessionManagerTest9, ProcessSubWindowRequestFocusImmediately4, TestSize.Level1)
1031 {
1032 ASSERT_NE(nullptr, ssm_);
1033 ssm_->sceneSessionMap_.clear();
1034 SessionInfo sessionInfo;
1035 sessionInfo.bundleName_ = "SceneSessionManagerTest9";
1036 sessionInfo.abilityName_ = "ProcessSubWindowRequestFocusImmediately4";
1037 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
1038 sceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1039 sceneSession->persistentId_ = 1;
1040
1041 SessionInfo subSessionInfo;
1042 sptr<SceneSession> subSession = sptr<SceneSession>::MakeSptr(subSessionInfo, nullptr);
1043 subSession->persistentId_ = 2;
1044 subSession->SetFocusable(true);
1045 subSession->SetFocusedOnShow(true);
1046 sceneSession->subSession_.push_back(subSession);
1047
1048 sceneSession->subSession_.push_back(nullptr);
1049
1050 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession));
1051 ssm_->sceneSessionMap_.insert(std::make_pair(2, subSession));
1052
1053 ssm_->windowFocusController_->UpdateFocusedSessionId(DEFAULT_DISPLAY_ID, 1);
1054 WSError ret = ssm_->ProcessSubWindowRequestFocusImmediately(sceneSession);
1055 EXPECT_EQ(ret, WSError::WS_DO_NOTHING);
1056 }
1057
1058 /**
1059 * @tc.name: ProcessSubWindowRequestFocusImmediately5
1060 * @tc.desc: Test sub session request focus success
1061 * @tc.type: FUNC
1062 */
1063 HWTEST_F(SceneSessionManagerTest9, ProcessSubWindowRequestFocusImmediately5, TestSize.Level1)
1064 {
1065 ASSERT_NE(nullptr, ssm_);
1066 ssm_->sceneSessionMap_.clear();
1067 SessionInfo sessionInfo;
1068 sessionInfo.bundleName_ = "SceneSessionManagerTest9";
1069 sessionInfo.abilityName_ = "ProcessSubWindowRequestFocusImmediately5";
1070 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
1071 sceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1072 sceneSession->persistentId_ = 1;
1073
1074 SessionInfo subSessionInfo;
1075 sptr<SceneSession> subSession = sptr<SceneSession>::MakeSptr(subSessionInfo, nullptr);
1076 subSession->persistentId_ = 2;
1077 subSession->SetFocusable(true);
1078 subSession->SetFocusedOnShow(true);
1079 subSession->UpdateVisibilityInner(true);
1080 subSession->SetSessionState(SessionState::STATE_FOREGROUND);
1081 sceneSession->subSession_.push_back(subSession);
1082
1083 sceneSession->subSession_.push_back(nullptr);
1084
1085 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession));
1086 ssm_->sceneSessionMap_.insert(std::make_pair(2, subSession));
1087
1088 ssm_->windowFocusController_->UpdateFocusedSessionId(DEFAULT_DISPLAY_ID, 1);
1089 WSError ret = ssm_->ProcessSubWindowRequestFocusImmediately(sceneSession);
1090 EXPECT_EQ(ret, WSError::WS_OK);
1091 ssm_->sceneSessionMap_.clear();
1092 }
1093
1094 /**
1095 * @tc.name: NotifyCompleteFirstFrameDrawing03
1096 * @tc.desc: NotifyCompleteFirstFrameDrawing
1097 * @tc.type: FUNC
1098 */
1099 HWTEST_F(SceneSessionManagerTest9, NotifyCompleteFirstFrameDrawing03, TestSize.Level1)
1100 {
1101 ASSERT_NE(nullptr, ssm_);
1102 SessionInfo sessionInfo;
1103 sessionInfo.bundleName_ = "SceneSessionManagerTest9";
1104 sessionInfo.abilityName_ = "NotifyCompleteFirstFrameDrawing03";
1105 std::shared_ptr<AppExecFwk::AbilityInfo> abilityInfo = std::make_shared<AppExecFwk::AbilityInfo>();
1106 abilityInfo->excludeFromMissions = true;
1107 sessionInfo.abilityInfo = abilityInfo;
1108 sessionInfo.isSystem_ = true;
1109 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
1110 ASSERT_NE(nullptr, sceneSession);
1111 sceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1112 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession));
1113 ssm_->NotifyCompleteFirstFrameDrawing(1);
1114
1115 std::shared_ptr<AppExecFwk::EventHandler> eventHandler = std::make_shared<AppExecFwk::EventHandler>();
1116 ssm_->eventHandler_ = eventHandler;
1117 abilityInfo->excludeFromMissions = false;
1118 ssm_->NotifyCompleteFirstFrameDrawing(1);
1119 }
1120
1121 /**
1122 * @tc.name: SetSessionLabel02
1123 * @tc.desc: SetSessionLabel
1124 * @tc.type: FUNC
1125 */
1126 HWTEST_F(SceneSessionManagerTest9, SetSessionLabel02, TestSize.Level1)
1127 {
1128 ASSERT_NE(nullptr, ssm_);
1129 SessionInfo sessionInfo;
1130 sessionInfo.bundleName_ = "SceneSessionManagerTest9";
1131 sessionInfo.abilityName_ = "SetSessionLabel02";
1132 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
1133 ASSERT_NE(nullptr, sceneSession);
1134 sptr<IRemoteObject> token = sptr<MockIRemoteObject>::MakeSptr();
1135 ASSERT_NE(nullptr, token);
1136 sceneSession->SetAbilityToken(token);
1137 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession));
1138 ssm_->listenerController_ = nullptr;
1139
1140 std::string label = "testLabel";
1141 ssm_->SetSessionLabel(token, label);
1142
1143 std::shared_ptr<SessionListenerController> listenerController = std::make_shared<SessionListenerController>();
1144 ssm_->listenerController_ = listenerController;
1145 sessionInfo.isSystem_ = false;
1146 ssm_->SetSessionLabel(token, label);
1147
1148 sessionInfo.isSystem_ = true;
1149 ssm_->SetSessionLabel(token, label);
1150 }
1151
1152 /**
1153 * @tc.name: RecoverAndReconnectSceneSession02
1154 * @tc.desc: RecoverAndReconnectSceneSession
1155 * @tc.type: FUNC
1156 */
1157 HWTEST_F(SceneSessionManagerTest9, RecoverAndReconnectSceneSession02, TestSize.Level1)
1158 {
1159 ASSERT_NE(nullptr, ssm_);
1160 SessionInfo sessionInfo;
1161 sessionInfo.bundleName_ = "SceneSessionManagerTest9";
1162 sessionInfo.abilityName_ = "RecoverAndReconnectSceneSession02";
1163 sessionInfo.moduleName_ = "moduleTest";
1164 sessionInfo.appIndex_ = 10;
1165 sessionInfo.persistentId_ = 1;
1166 std::shared_ptr<AppExecFwk::AbilityInfo> abilityInfo = std::make_shared<AppExecFwk::AbilityInfo>();
1167 abilityInfo->excludeFromMissions = true;
1168 sessionInfo.abilityInfo = abilityInfo;
1169 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
1170 ASSERT_NE(nullptr, sceneSession);
1171
1172 sptr<WindowSessionProperty> property = sceneSession->GetSessionProperty();
1173 property->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1174 property->SetPersistentId(1);
1175 property->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1176 property->SetWindowState(WindowState::STATE_SHOWN);
1177 property->SetRequestedOrientation(Orientation::UNSPECIFIED);
1178 ssm_->alivePersistentIds_.push_back(1);
1179 ssm_->recoveringFinished_ = false;
1180 ssm_->recoverSceneSessionFunc_ = NotifyRecoverSceneSessionFuncTest;
1181
1182 sptr<ISession> session;
1183 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession));
1184 auto result = ssm_->RecoverAndReconnectSceneSession(nullptr, nullptr, nullptr, session, property, nullptr);
1185 ASSERT_EQ(result, WSError::WS_ERROR_INVALID_SESSION);
1186
1187 property->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1188 property->SetPersistentId(2);
1189 result = ssm_->RecoverAndReconnectSceneSession(nullptr, nullptr, nullptr, session, property, nullptr);
1190 ASSERT_EQ(result, WSError::WS_ERROR_INVALID_PARAM);
1191 }
1192
1193 /**
1194 * @tc.name: RefreshPcZorder
1195 * @tc.desc: RefreshPcZorder
1196 * @tc.type: FUNC
1197 */
1198 HWTEST_F(SceneSessionManagerTest9, RefreshPcZorder, TestSize.Level0)
1199 {
1200 std::vector<int32_t> persistentIds;
1201 SessionInfo info1;
1202 info1.abilityName_ = "RefreshPcZorder1";
1203 info1.bundleName_ = "RefreshPcZorder1";
1204 sptr<SceneSession> session1 = sptr<SceneSession>::MakeSptr(info1, nullptr);
1205 ASSERT_NE(session1, nullptr);
1206 persistentIds.push_back(session1->GetPersistentId());
1207 ssm_->sceneSessionMap_.insert({ session1->GetPersistentId(), session1 });
1208 SessionInfo info2;
1209 info2.abilityName_ = "RefreshPcZorder2";
1210 info2.bundleName_ = "RefreshPcZorder2";
1211 sptr<SceneSession> session2 = sptr<SceneSession>::MakeSptr(info2, nullptr);
1212 ASSERT_NE(session2, nullptr);
1213 persistentIds.push_back(session2->GetPersistentId());
1214 ssm_->sceneSessionMap_.insert({ session2->GetPersistentId(), session2 });
1215 SessionInfo info3;
1216 info3.abilityName_ = "RefreshPcZorder3";
1217 info3.bundleName_ = "RefreshPcZorder3";
1218 sptr<SceneSession> session3 = sptr<SceneSession>::MakeSptr(info3, nullptr);
1219 ASSERT_NE(session3, nullptr);
1220 session3->SetZOrder(404);
1221 ssm_->sceneSessionMap_.insert({ session3->GetPersistentId(), session3 });
1222 persistentIds.push_back(999);
1223 uint32_t startZOrder = 100;
1224 std::vector<int32_t> newPersistentIds = persistentIds;
1225 ssm_->RefreshPcZOrderList(startZOrder, std::move(persistentIds));
1226 ssm_->RefreshPcZOrderList(UINT32_MAX, std::move(newPersistentIds));
1227 auto start = std::chrono::system_clock::now();
1228 // Due to RefreshPcZOrderList being asynchronous, spin lock is added.
1229 // The spin lock itself is set with a timeout escape time of 3 seconds
1230 while (true) {
1231 if ((session1->GetZOrder() != 0 && session2->GetZOrder() != 0 && session1->GetZOrder() != 100) ||
1232 std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now() - start).count() >= 3) {
1233 break;
1234 }
1235 std::this_thread::sleep_for(std::chrono::milliseconds(100));
1236 }
1237 ASSERT_EQ(session2->GetZOrder(), 101);
1238 ASSERT_EQ(session3->GetZOrder(), 404);
1239 ASSERT_EQ(session1->GetZOrder(), UINT32_MAX);
1240 }
1241
1242 /**
1243 * @tc.name: GetSessionRSVisible
1244 * @tc.desc: GetSessionRSVisible
1245 * @tc.type: FUNC
1246 */
1247 HWTEST_F(SceneSessionManagerTest9, GetSessionRSVisible, TestSize.Level1)
1248 {
1249 ASSERT_NE(nullptr, ssm_);
1250 SessionInfo sessionInfo;
1251 sessionInfo.bundleName_ = "SceneSessionManagerTest9";
1252 sessionInfo.abilityName_ = "GetSessionRSVisible";
1253 sessionInfo.moduleName_ = "moduleTest";
1254 uint64_t windowId = 10;
1255 sptr<SceneSession> sceneSession01 = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
1256 sceneSession01->persistentId_ = windowId;
1257 sptr<SceneSession> sceneSession02 = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
1258 std::vector<std::pair<uint64_t, WindowVisibilityState>> currVisibleData;
1259 currVisibleData.push_back(std::make_pair(0, WindowVisibilityState::WINDOW_VISIBILITY_STATE_NO_OCCLUSION));
1260 currVisibleData.push_back(std::make_pair(1, WindowVisibilityState::WINDOW_VISIBILITY_STATE_PARTICALLY_OCCLUSION));
1261 struct RSSurfaceNodeConfig config;
1262 sceneSession02->surfaceNode_ = RSSurfaceNode::Create(config);
1263 ASSERT_NE(nullptr, sceneSession02->surfaceNode_);
1264 sceneSession02->surfaceNode_->id_ = 0;
1265 sceneSession02->persistentId_ = windowId;
1266 ssm_->sceneSessionMap_.insert(std::make_pair(0, sceneSession02));
1267
1268 bool actual = ssm_->GetSessionRSVisible(sceneSession01, currVisibleData);
1269 EXPECT_EQ(actual, true);
1270 }
1271
1272 /**
1273 * @tc.name: CheckClickFocusIsDownThroughFullScreen
1274 * @tc.desc: CheckClickFocusIsDownThroughFullScreen
1275 * @tc.type: FUNC
1276 */
1277 HWTEST_F(SceneSessionManagerTest9, CheckClickFocusIsDownThroughFullScreen, TestSize.Level1)
1278 {
1279 ASSERT_NE(ssm_, nullptr);
1280 SessionInfo info;
1281 info.abilityName_ = "test1";
1282 info.bundleName_ = "test2";
1283
1284 sptr<SceneSession> focusedSession = sptr<SceneSession>::MakeSptr(info, nullptr);
1285 ASSERT_NE(focusedSession, nullptr);
1286 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
1287 ASSERT_NE(sceneSession, nullptr);
1288 bool ret = ssm_->CheckClickFocusIsDownThroughFullScreen(focusedSession, sceneSession, FocusChangeReason::DEFAULT);
1289 ASSERT_EQ(ret, false);
1290
1291 focusedSession->property_->SetWindowType(WindowType::WINDOW_TYPE_GLOBAL_SEARCH);
1292 ret = ssm_->CheckClickFocusIsDownThroughFullScreen(focusedSession, sceneSession, FocusChangeReason::DEFAULT);
1293 ASSERT_EQ(ret, false);
1294 sceneSession->SetZOrder(50);
1295 focusedSession->SetZOrder(100);
1296 focusedSession->blockingFocus_ = true;
1297 ret = ssm_->CheckClickFocusIsDownThroughFullScreen(focusedSession, sceneSession, FocusChangeReason::CLICK);
1298 ASSERT_EQ(ret, true);
1299 }
1300
1301 /**
1302 * @tc.name: ShiftFocus
1303 * @tc.desc: ShiftFocus
1304 * @tc.type: FUNC
1305 */
1306 HWTEST_F(SceneSessionManagerTest9, ShiftFocus, TestSize.Level1)
1307 {
1308 ASSERT_NE(ssm_, nullptr);
1309 ssm_->sceneSessionMap_.clear();
1310 SessionInfo info;
1311 info.abilityName_ = "test1";
1312 info.bundleName_ = "test2";
1313 sptr<SceneSession> focusedSession = sptr<SceneSession>::MakeSptr(info, nullptr);
1314 ASSERT_NE(focusedSession, nullptr);
1315 sptr<SceneSession> nextSession = sptr<SceneSession>::MakeSptr(info, nullptr);
1316 ASSERT_NE(nextSession, nullptr);
1317 focusedSession->persistentId_ = 1;
1318 nextSession->persistentId_ = 4;
1319 ssm_->sceneSessionMap_.insert({ 1, focusedSession });
1320 ssm_->sceneSessionMap_.insert({ 4, nextSession });
1321 auto focusGroup = ssm_->windowFocusController_->GetFocusGroup(DEFAULT_DISPLAY_ID);
1322 focusGroup->SetFocusedSessionId(1);
1323 WSError ret = ssm_->ShiftFocus(DEFAULT_DISPLAY_ID, nextSession, false, FocusChangeReason::DEFAULT);
1324 ASSERT_EQ(ret, WSError::WS_OK);
1325 ASSERT_EQ(focusedSession->isFocused_, false);
1326 ASSERT_EQ(nextSession->isFocused_, true);
1327 }
1328
1329 /**
1330 * @tc.name: CheckUIExtensionCreation
1331 * @tc.desc: CheckUIExtensionCreation
1332 * @tc.type: FUNC
1333 */
1334 HWTEST_F(SceneSessionManagerTest9, CheckUIExtensionCreation, TestSize.Level1)
1335 {
1336 ASSERT_NE(ssm_, nullptr);
1337 AppExecFwk::ElementName element;
1338 int32_t windowId = 5;
1339 uint32_t callingTokenId = 0;
1340 int32_t pid = 0;
1341 bool isSystemCalling = SessionPermission::IsSystemCalling();
1342 AppExecFwk::ExtensionAbilityType extensionAbilityType = AppExecFwk::ExtensionAbilityType::ACTION;
1343 auto ret = ssm_->CheckUIExtensionCreation(windowId, callingTokenId, element, extensionAbilityType, pid);
1344 ASSERT_EQ(ret, isSystemCalling ? WMError::WM_ERROR_INVALID_WINDOW : WMError::WM_ERROR_NOT_SYSTEM_APP);
1345
1346 SessionInfo info;
1347 sptr<SceneSession::SpecificSessionCallback> callback = sptr<SceneSession::SpecificSessionCallback>::MakeSptr();
1348 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, callback);
1349 ssm_->sceneSessionMap_.insert(std::pair<int32_t, sptr<SceneSession>>(0, sceneSession));
1350 windowId = 0;
1351
1352 Session session(info);
1353 session.getStateFromManagerFunc_ = getStateFalse;
1354 ret = ssm_->CheckUIExtensionCreation(windowId, callingTokenId, element, extensionAbilityType, pid);
1355 ASSERT_EQ(ret, isSystemCalling ? WMError::WM_OK : WMError::WM_ERROR_NOT_SYSTEM_APP);
1356
1357 session.getStateFromManagerFunc_ = getStateTrue;
1358 ssm_->CheckUIExtensionCreation(windowId, callingTokenId, element, extensionAbilityType, pid);
1359 }
1360
1361 /**
1362 * @tc.name: CheckUIExtensionCreation01
1363 * @tc.desc: CheckUIExtensionCreation
1364 * @tc.type: FUNC
1365 */
1366 HWTEST_F(SceneSessionManagerTest9, CheckUIExtensionCreation01, TestSize.Level1)
1367 {
1368 ASSERT_NE(ssm_, nullptr);
1369 AppExecFwk::ElementName element;
1370 int32_t windowId = 0;
1371 uint32_t callingTokenId = 0;
1372 int32_t pid = 0;
1373 bool isSystemCalling = SessionPermission::IsSystemCalling();
1374 AppExecFwk::ExtensionAbilityType extensionAbilityType = AppExecFwk::ExtensionAbilityType::ACTION;
1375
1376 SessionInfo info;
1377 sptr<SceneSession::SpecificSessionCallback> callback = sptr<SceneSession::SpecificSessionCallback>::MakeSptr();
1378 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, callback);
1379 ssm_->sceneSessionMap_.insert(std::pair<int32_t, sptr<SceneSession>>(0, sceneSession));
1380 Session session(info);
1381 session.getStateFromManagerFunc_ = getStateTrue;
1382 auto ret = ssm_->CheckUIExtensionCreation(windowId, callingTokenId, element, extensionAbilityType, pid);
1383
1384 session.property_ = nullptr;
1385 ret = ssm_->CheckUIExtensionCreation(windowId, callingTokenId, element, extensionAbilityType, pid);
1386 ASSERT_EQ(ret, isSystemCalling ? WMError::WM_OK : WMError::WM_ERROR_NOT_SYSTEM_APP);
1387
1388 sceneSession->IsShowOnLockScreen(0);
1389 session.zOrder_ = 1;
1390 ssm_->CheckUIExtensionCreation(windowId, callingTokenId, element, extensionAbilityType, pid);
1391 ASSERT_EQ(ret, isSystemCalling ? WMError::WM_OK : WMError::WM_ERROR_NOT_SYSTEM_APP);
1392 }
1393
1394 /**
1395 * @tc.name: GetLockScreenZOrder
1396 * @tc.desc: GetLockScreenZOrder
1397 * @tc.type: FUNC
1398 */
1399 HWTEST_F(SceneSessionManagerTest9, GetLockScreenZOrder, TestSize.Level1)
1400 {
1401 ASSERT_NE(ssm_, nullptr);
1402 ssm_->sceneSessionMap_.clear();
1403 SessionInfo info;
1404 sptr<SceneSession::SpecificSessionCallback> callback = sptr<SceneSession::SpecificSessionCallback>::MakeSptr();
1405 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, callback);
1406 constexpr uint32_t DEFAULT_LOCK_SCREEN_ZORDER = 2000;
1407 constexpr uint32_t LOCK_SCREEN_ZORDER = 2003;
1408 ssm_->sceneSessionMap_.insert(std::pair<int32_t, sptr<SceneSession>>(0, sceneSession));
1409 ASSERT_EQ(ssm_->GetLockScreenZOrder(), DEFAULT_LOCK_SCREEN_ZORDER);
1410 ASSERT_EQ(sceneSession->IsScreenLockWindow(), false);
1411 ASSERT_EQ(sceneSession->GetZOrder(), 0);
1412
1413 info.bundleName_ = "SCBScreenLock2";
1414 sptr<SceneSession> lockScreenSession = sptr<SceneSession>::MakeSptr(info, nullptr);
1415 ssm_->sceneSessionMap_.insert(std::pair<int32_t, sptr<SceneSession>>(1, lockScreenSession));
1416 lockScreenSession->SetZOrder(0);
1417 ASSERT_EQ(ssm_->GetLockScreenZOrder(), DEFAULT_LOCK_SCREEN_ZORDER);
1418 lockScreenSession->SetZOrder(DEFAULT_LOCK_SCREEN_ZORDER);
1419 ASSERT_EQ(ssm_->GetLockScreenZOrder(), DEFAULT_LOCK_SCREEN_ZORDER);
1420 lockScreenSession->SetZOrder(DEFAULT_LOCK_SCREEN_ZORDER - 1);
1421 ASSERT_EQ(ssm_->GetLockScreenZOrder(), DEFAULT_LOCK_SCREEN_ZORDER);
1422 lockScreenSession->SetZOrder(LOCK_SCREEN_ZORDER);
1423 ASSERT_EQ(lockScreenSession->IsScreenLockWindow(), true);
1424 ASSERT_EQ(lockScreenSession->GetZOrder(), LOCK_SCREEN_ZORDER);
1425 ASSERT_EQ(ssm_->sceneSessionMap_.size(), 2);
1426 ASSERT_EQ(ssm_->GetLockScreenZOrder(), LOCK_SCREEN_ZORDER);
1427 }
1428
1429 /**
1430 * @tc.name: IsLastPiPWindowVisible
1431 * @tc.desc: IsLastPiPWindowVisible
1432 * @tc.type: FUNC
1433 */
1434 HWTEST_F(SceneSessionManagerTest9, IsLastPiPWindowVisible, TestSize.Level1)
1435 {
1436 uint64_t surfaceId = 0;
1437 WindowVisibilityState lastVisibilityState = WindowVisibilityState::WINDOW_VISIBILITY_STATE_NO_OCCLUSION;
1438 ssm_->sceneSessionMap_.insert(std::pair<int32_t, sptr<SceneSession>>(0, nullptr));
1439 auto ret = ssm_->IsLastPiPWindowVisible(surfaceId, lastVisibilityState);
1440 ASSERT_EQ(ret, false);
1441 }
1442
1443 /**
1444 * @tc.name: IsLastPiPWindowVisible01
1445 * @tc.desc: IsLastPiPWindowVisible
1446 * @tc.type: FUNC
1447 */
1448 HWTEST_F(SceneSessionManagerTest9, IsLastPiPWindowVisible01, TestSize.Level1)
1449 {
1450 uint64_t surfaceId = 0;
1451 WindowVisibilityState lastVisibilityState = WindowVisibilityState::WINDOW_VISIBILITY_STATE_NO_OCCLUSION;
1452
1453 SessionInfo info;
1454 sptr<SceneSession::SpecificSessionCallback> callback = sptr<SceneSession::SpecificSessionCallback>::MakeSptr();
1455 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, callback);
1456 ssm_->sceneSessionMap_.insert(std::pair<int32_t, sptr<SceneSession>>(0, nullptr));
1457
1458 struct RSSurfaceNodeConfig config;
1459 sceneSession->surfaceNode_ = RSSurfaceNode::Create(config);
1460 ASSERT_NE(nullptr, sceneSession->surfaceNode_);
1461 sceneSession->surfaceNode_->id_ = 0;
1462 ssm_->SelectSesssionFromMap(0);
1463 sptr<WindowSessionProperty> property = sceneSession->GetSessionProperty();
1464 property->SetWindowMode(WindowMode::WINDOW_MODE_PIP);
1465
1466 auto ret = ssm_->IsLastPiPWindowVisible(surfaceId, lastVisibilityState);
1467 ASSERT_EQ(ret, false);
1468 ssm_->isScreenLocked_ = true;
1469 ret = ssm_->IsLastPiPWindowVisible(surfaceId, lastVisibilityState);
1470 ASSERT_EQ(ret, false);
1471 lastVisibilityState = WindowVisibilityState::WINDOW_VISIBILITY_STATE_TOTALLY_OCCUSION;
1472 ret = ssm_->IsLastPiPWindowVisible(surfaceId, lastVisibilityState);
1473 ASSERT_EQ(ret, false);
1474 }
1475
1476 /**
1477 * @tc.name: UpdateSpecificSessionClientDisplayId01
1478 * @tc.desc: UpdateSpecificSessionClientDisplayId
1479 * @tc.type: FUNC
1480 */
1481 HWTEST_F(SceneSessionManagerTest9, UpdateSpecificSessionClientDisplayId01, TestSize.Level1)
1482 {
1483 ASSERT_NE(nullptr, ssm_);
1484 ssm_->sceneSessionMap_.clear();
1485 SessionInfo sessionInfo;
1486 sessionInfo.bundleName_ = "SceneSessionManagerTest9";
1487 sessionInfo.abilityName_ = "UpdateSpecificSessionClientDisplayId";
1488 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
1489 ASSERT_NE(nullptr, sceneSession);
1490 sceneSession->persistentId_ = 1;
1491 ssm_->sceneSessionMap_.insert({ 1, sceneSession });
1492 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
1493 ASSERT_NE(nullptr, property);
1494 property->SetParentPersistentId(1);
1495 auto displayId = ssm_->UpdateSpecificSessionClientDisplayId(property);
1496 EXPECT_EQ(0, displayId);
1497 EXPECT_EQ(0, property->GetDisplayId());
1498
1499 property->SetDisplayId(999);
1500 displayId = ssm_->UpdateSpecificSessionClientDisplayId(property);
1501 EXPECT_EQ(999, displayId);
1502 EXPECT_EQ(0, property->GetDisplayId());
1503
1504 property->SetDisplayId(999);
1505 property->SetIsFollowParentWindowDisplayId(true);
1506 displayId = ssm_->UpdateSpecificSessionClientDisplayId(property);
1507 EXPECT_EQ(0, displayId);
1508 EXPECT_EQ(0, property->GetDisplayId());
1509 }
1510
1511 /**
1512 * @tc.name: UpdateSpecificSessionClientDisplayId02
1513 * @tc.desc: UpdateSpecificSessionClientDisplayId
1514 * @tc.type: FUNC
1515 */
1516 HWTEST_F(SceneSessionManagerTest9, UpdateSpecificSessionClientDisplayId02, TestSize.Level1)
1517 {
1518 ASSERT_NE(nullptr, ssm_);
1519 ssm_->sceneSessionMap_.clear();
1520 SessionInfo sessionInfo;
1521 sessionInfo.bundleName_ = "SceneSessionManagerTest9";
1522 sessionInfo.abilityName_ = "UpdateSpecificSessionClientDisplayId";
1523 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
1524 ASSERT_NE(nullptr, sceneSession);
1525 sceneSession->persistentId_ = 1;
1526 sceneSession->SetClientDisplayId(999);
1527 ssm_->sceneSessionMap_.insert({ 1, sceneSession });
1528 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
1529 ASSERT_NE(nullptr, property);
1530 property->SetParentPersistentId(1);
1531 auto displayId = ssm_->UpdateSpecificSessionClientDisplayId(property);
1532 EXPECT_EQ(999, displayId);
1533 EXPECT_EQ(0, property->GetDisplayId());
1534
1535 property->SetDisplayId(999);
1536 displayId = ssm_->UpdateSpecificSessionClientDisplayId(property);
1537 EXPECT_EQ(999, displayId);
1538 EXPECT_EQ(0, property->GetDisplayId());
1539 }
1540
1541 /**
1542 * @tc.name: UpdateSpecificSessionClientDisplayId03
1543 * @tc.desc: UpdateSpecificSessionClientDisplayId
1544 * @tc.type: FUNC
1545 */
1546 HWTEST_F(SceneSessionManagerTest9, UpdateSpecificSessionClientDisplayId03, TestSize.Level1)
1547 {
1548 ASSERT_NE(nullptr, ssm_);
1549 ssm_->sceneSessionMap_.clear();
1550 SessionInfo sessionInfo;
1551 sessionInfo.bundleName_ = "SceneSessionManagerTest9";
1552 sessionInfo.abilityName_ = "UpdateSpecificSessionClientDisplayId";
1553 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
1554 ASSERT_NE(nullptr, property);
1555 auto displayId = ssm_->UpdateSpecificSessionClientDisplayId(property);
1556 EXPECT_EQ(0, displayId);
1557 EXPECT_EQ(0, property->GetDisplayId());
1558
1559 property->SetDisplayId(999);
1560 displayId = ssm_->UpdateSpecificSessionClientDisplayId(property);
1561 EXPECT_EQ(999, displayId);
1562 EXPECT_EQ(0, property->GetDisplayId());
1563 }
1564
1565 /**
1566 * @tc.name: SetSkipEventOnCastPlusInner01
1567 * @tc.desc: SetSkipEventOnCastPlusInner
1568 * @tc.type: FUNC
1569 */
1570 HWTEST_F(SceneSessionManagerTest9, SetSkipEventOnCastPlusInner01, TestSize.Level1)
1571 {
1572 ASSERT_NE(nullptr, ssm_);
1573 ssm_->sceneSessionMap_.clear();
1574 SessionInfo sessionInfo;
1575 sessionInfo.bundleName_ = "SceneSessionManagerTest9";
1576 sessionInfo.abilityName_ = "SetSkipEventOnCastPlusInner";
1577 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
1578 ASSERT_NE(nullptr, sceneSession);
1579 ssm_->sceneSessionMap_.insert({ sceneSession->GetPersistentId(), sceneSession });
1580 ssm_->SetSkipEventOnCastPlusInner(sceneSession->GetPersistentId(), true);
1581 EXPECT_EQ(true, sceneSession->GetSessionProperty()->GetSkipEventOnCastPlus());
1582 ssm_->SetSkipEventOnCastPlusInner(sceneSession->GetPersistentId(), false);
1583 EXPECT_EQ(false, sceneSession->GetSessionProperty()->GetSkipEventOnCastPlus());
1584 }
1585 } // namespace
1586 } // namespace Rosen
1587 } // namespace OHOS