1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include <regex>
18 #include <chrono>
19 #include <thread>
20 #include <bundle_mgr_interface.h>
21 #include <bundlemgr/launcher_service.h>
22 #include "interfaces/include/ws_common.h"
23 #include "screen_fold_data.h"
24 #include "session_manager/include/ffrt_queue_helper.h"
25 #include "session_manager/include/scene_session_manager.h"
26 #include "session_info.h"
27 #include "session/host/include/scene_session.h"
28 #include "session/host/include/main_session.h"
29 #include "window_manager_agent.h"
30 #include "session_manager.h"
31 #include "zidl/window_manager_agent_interface.h"
32 #include "mock/mock_session_stage.h"
33 #include "mock/mock_window_event_channel.h"
34 #include "application_info.h"
35 #include "context.h"
36
37 using namespace testing;
38 using namespace testing::ext;
39
40 namespace OHOS {
41 namespace Rosen {
42 namespace {
43 const std::string EMPTY_DEVICE_ID = "";
44 }
45 class SceneSessionManagerLifecycleTest : public testing::Test {
46 public:
47 static void SetUpTestCase();
48
49 static void TearDownTestCase();
50
51 void SetUp() override;
52
53 void TearDown() override;
54
55 static void SetVisibleForAccessibility(sptr<SceneSession>& sceneSession);
56 int32_t GetTaskCount(sptr<SceneSession>& session);
57 static sptr<SceneSessionManager> ssm_;
58 private:
59 static constexpr uint32_t WAIT_SYNC_IN_NS = 200000;
60 };
61
62 sptr<SceneSessionManager> SceneSessionManagerLifecycleTest::ssm_ = nullptr;
63
WindowChangedFuncTest(int32_t persistentId,WindowUpdateType type)64 void WindowChangedFuncTest(int32_t persistentId, WindowUpdateType type)
65 {
66 }
67
ProcessStatusBarEnabledChangeFuncTest(bool enable)68 void ProcessStatusBarEnabledChangeFuncTest(bool enable)
69 {
70 }
71
DumpRootSceneElementInfoFuncTest(const std::vector<std::string> & params,std::vector<std::string> & infos)72 void DumpRootSceneElementInfoFuncTest(const std::vector<std::string>& params, std::vector<std::string>& infos)
73 {
74 }
75
SetUpTestCase()76 void SceneSessionManagerLifecycleTest::SetUpTestCase()
77 {
78 ssm_ = &SceneSessionManager::GetInstance();
79 }
80
TearDownTestCase()81 void SceneSessionManagerLifecycleTest::TearDownTestCase()
82 {
83 ssm_ = nullptr;
84 }
85
SetUp()86 void SceneSessionManagerLifecycleTest::SetUp()
87 {
88 ssm_->sceneSessionMap_.clear();
89 }
90
TearDown()91 void SceneSessionManagerLifecycleTest::TearDown()
92 {
93 usleep(WAIT_SYNC_IN_NS);
94 ssm_->sceneSessionMap_.clear();
95 }
96
SetVisibleForAccessibility(sptr<SceneSession> & sceneSession)97 void SceneSessionManagerLifecycleTest::SetVisibleForAccessibility(sptr<SceneSession>& sceneSession)
98 {
99 sceneSession->SetTouchable(true);
100 sceneSession->forceTouchable_ = true;
101 sceneSession->systemTouchable_ = true;
102 sceneSession->state_ = SessionState::STATE_FOREGROUND;
103 sceneSession->foregroundInteractiveStatus_.store(true);
104 }
105
GetTaskCount(sptr<SceneSession> & session)106 int32_t SceneSessionManagerLifecycleTest::GetTaskCount(sptr<SceneSession>& session)
107 {
108 std::string dumpInfo = session->handler_->GetEventRunner()->GetEventQueue()->DumpCurrentQueueSize();
109 std::regex pattern("\\d+");
110 std::smatch matches;
111 int32_t taskNum = 0;
112 while (std::regex_search(dumpInfo, matches, pattern)) {
113 taskNum += std::stoi(matches.str());
114 dumpInfo = matches.suffix();
115 }
116 return taskNum;
117 }
118
119 namespace {
120 /**
121 * @tc.name: NotifySessionForeground
122 * @tc.desc: SceneSesionManager NotifySessionForeground
123 * @tc.type: FUNC
124 */
125 HWTEST_F(SceneSessionManagerLifecycleTest, NotifySessionForeground, Function | SmallTest | Level3)
126 {
127 sptr<SceneSession> sceneSession = nullptr;
128 SessionInfo info;
129 info.bundleName_ = "bundleName";
130 sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
131 ASSERT_NE(nullptr, sceneSession);
132 uint32_t reason = 1;
133 bool withAnimation = true;
134 sceneSession->NotifySessionForeground(reason, withAnimation);
135 }
136
137 /**
138 * @tc.name: NotifySessionForeground
139 * @tc.desc: SceneSesionManager NotifySessionForeground
140 * @tc.type: FUNC
141 */
142 HWTEST_F(SceneSessionManagerLifecycleTest, NotifySessionBackground, Function | SmallTest | Level3)
143 {
144 sptr<SceneSession> sceneSession = nullptr;
145 SessionInfo info;
146 info.bundleName_ = "bundleName";
147 sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
148 ASSERT_NE(nullptr, sceneSession);
149 uint32_t reason = 1;
150 bool withAnimation = true;
151 bool isFromInnerkits = true;
152 sceneSession->NotifySessionBackground(reason, withAnimation, isFromInnerkits);
153 }
154
155 /**
156 * @tc.name: ClearUnrecoveredSessions
157 * @tc.desc: test func ClearUnrecoveredSessions
158 * @tc.type: FUNC
159 */
160 HWTEST_F(SceneSessionManagerLifecycleTest, ClearUnrecoveredSessions, Function | SmallTest | Level1)
161 {
162 ssm_->alivePersistentIds_.push_back(23);
163 ssm_->alivePersistentIds_.push_back(24);
164 ssm_->alivePersistentIds_.push_back(25);
165 EXPECT_FALSE(ssm_->alivePersistentIds_.empty());
166 std::vector<int32_t> recoveredPersistentIds;
167 recoveredPersistentIds.push_back(23);
168 recoveredPersistentIds.push_back(24);
169 ssm_->ClearUnrecoveredSessions(recoveredPersistentIds);
170 }
171
172 /**
173 * @tc.name: RecoverSessionInfo
174 * @tc.desc: test func RecoverSessionInfo
175 * @tc.type: FUNC
176 */
177 HWTEST_F(SceneSessionManagerLifecycleTest, RecoverSessionInfo, Function | SmallTest | Level1)
178 {
179 SessionInfo info = ssm_->RecoverSessionInfo(nullptr);
180
181 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
182 ASSERT_NE(nullptr, property);
183 info = ssm_->RecoverSessionInfo(property);
184 }
185
186 /**
187 * @tc.name: NotifySessionMovedToFront
188 * @tc.desc: Test if pip window can be created;
189 * @tc.type: FUNC
190 */
191 HWTEST_F(SceneSessionManagerLifecycleTest, NotifySessionMovedToFront, Function | SmallTest | Level3)
192 {
193 ASSERT_NE(nullptr, ssm_);
194 ssm_->NotifySessionMovedToFront(0);
195
196 SessionInfo info;
197 info.abilityName_ = "BackgroundTask02";
198 info.bundleName_ = "BackgroundTask02";
199 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
200 ssm_->sceneSessionMap_.insert({100, sceneSession});
201 ssm_->NotifySessionMovedToFront(100);
202 }
203
204 /**
205 * @tc.name: PendingSessionToBackgroundForDelegator
206 * @tc.desc: Test if pip window can be created;
207 * @tc.type: FUNC
208 */
209 HWTEST_F(SceneSessionManagerLifecycleTest, PendingSessionToBackgroundForDelegator, Function | SmallTest | Level3)
210 {
211 WSError ret;
212 ret = ssm_->PendingSessionToBackgroundForDelegator(nullptr, true);
213 ASSERT_EQ(WSError::WS_ERROR_INVALID_PARAM, ret);
214
215 SessionInfo info;
216 info.abilityName_ = "BackgroundTask02";
217 info.bundleName_ = "BackgroundTask02";
218 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
219 ssm_->sceneSessionMap_.insert({100, sceneSession});
220 ret = ssm_->PendingSessionToBackgroundForDelegator(nullptr, true);
221 ASSERT_EQ(WSError::WS_ERROR_INVALID_PARAM, ret);
222 }
223
224 /**
225 * @tc.name: OnSessionStateChange
226 * @tc.desc: Test if pip window can be created;
227 * @tc.type: FUNC
228 */
229 HWTEST_F(SceneSessionManagerLifecycleTest, OnSessionStateChange, Function | SmallTest | Level3)
230 {
231 ssm_->sceneSessionMap_.clear();
232 ssm_->OnSessionStateChange(100, SessionState::STATE_END);
233 SessionInfo info;
234 info.abilityName_ = "BackgroundTask02";
235 info.bundleName_ = "BackgroundTask02";
236 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
237 ASSERT_NE(nullptr, sceneSession);
238 ssm_->sceneSessionMap_.insert({100, sceneSession});
239 ssm_->OnSessionStateChange(100, SessionState::STATE_END);
240 ssm_->OnSessionStateChange(100, SessionState::STATE_FOREGROUND);
241 ssm_->OnSessionStateChange(0, SessionState::STATE_FOREGROUND);
242 sceneSession->focusedOnShow_ = false;
243 ssm_->OnSessionStateChange(0, SessionState::STATE_FOREGROUND);
244 ssm_->OnSessionStateChange(100, SessionState::STATE_BACKGROUND);
245 ssm_->OnSessionStateChange(0, SessionState::STATE_BACKGROUND);
246
247 sptr<WindowSessionProperty> property_ = sptr<WindowSessionProperty>::MakeSptr();
248 ASSERT_NE(nullptr, property_);
249 property_->type_ = WindowType::APP_MAIN_WINDOW_END;
250 sceneSession->property_ = property_;
251 ssm_->OnSessionStateChange(100, SessionState::STATE_END);
252 ssm_->OnSessionStateChange(100, SessionState::STATE_FOREGROUND);
253 ssm_->OnSessionStateChange(0, SessionState::STATE_FOREGROUND);
254 ssm_->OnSessionStateChange(100, SessionState::STATE_BACKGROUND);
255 ssm_->OnSessionStateChange(0, SessionState::STATE_BACKGROUND);
256 ASSERT_NE(nullptr, ssm_);
257 }
258
259 /**
260 * @tc.name: RecoverAndReconnectSceneSession
261 * @tc.desc: check func RecoverAndReconnectSceneSession
262 * @tc.type: FUNC
263 */
264 HWTEST_F(SceneSessionManagerLifecycleTest, RecoverAndReconnectSceneSession, Function | SmallTest | Level2)
265 {
266 sptr<ISession> session;
267 auto result = ssm_->RecoverAndReconnectSceneSession(nullptr, nullptr, nullptr, session, nullptr, nullptr);
268 ASSERT_EQ(result, WSError::WS_ERROR_NULLPTR);
269
270 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
271 ASSERT_NE(nullptr, property);
272 std::vector<int32_t> recoveredPersistentIds = { 0, 1, 2 };
273 ssm_->SetAlivePersistentIds(recoveredPersistentIds);
274 property->SetPersistentId(1);
275 result = ssm_->RecoverAndReconnectSceneSession(nullptr, nullptr, nullptr, session, property, nullptr);
276 ASSERT_EQ(result, WSError::WS_ERROR_NULLPTR);
277 }
278
279 /**
280 * @tc.name: RecoverAndReconnectSceneSession
281 * @tc.desc: check func RecoverAndReconnectSceneSession
282 * @tc.type: FUNC
283 */
284 HWTEST_F(SceneSessionManagerLifecycleTest, RecoverAndReconnectSceneSession02, Function | SmallTest | Level2)
285 {
286 sptr<ISession> session;
287 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
288 ASSERT_NE(nullptr, property);
289 std::vector<int32_t> recoveredPersistentIds = {0, 1, 2};
290 ssm_->SetAlivePersistentIds(recoveredPersistentIds);
291 property->SetPersistentId(1);
292 ProcessShiftFocusFunc shiftFocusFunc_;
293 auto result = ssm_->RecoverAndReconnectSceneSession(nullptr, nullptr, nullptr, session, property, nullptr);
294 property->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
295 result = ssm_->RecoverAndReconnectSceneSession(nullptr, nullptr, nullptr, session, property, nullptr);
296 ASSERT_EQ(result, WSError::WS_ERROR_NULLPTR);
297 }
298
299 /**
300 * @tc.name: CreateSceneSession
301 * @tc.desc: CreateSceneSession
302 * @tc.type: FUNC
303 */
304 HWTEST_F(SceneSessionManagerLifecycleTest, CreateSceneSession, Function | SmallTest | Level3)
305 {
306 SessionInfo info;
307 ssm_->CreateSceneSession(info, nullptr);
308 info.isSystem_ = true;
309 info.windowType_ = 3000;
310 ssm_->CreateSceneSession(info, nullptr);
311 info.windowType_ = 3;
312 ssm_->CreateSceneSession(info, nullptr);
313 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
314 ASSERT_NE(nullptr, property);
315 sptr<SceneSession> getSceneSession1 = ssm_->CreateSceneSession(info, property);
316 ASSERT_NE(nullptr, getSceneSession1);
317
318 property->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
319 info.windowType_ = 1001;
320 sptr<SceneSession> getSceneSession2 = ssm_->CreateSceneSession(info, property);
321 ASSERT_NE(nullptr, getSceneSession2);
322 ASSERT_EQ(WindowType::WINDOW_TYPE_APP_SUB_WINDOW, getSceneSession2->GetWindowType());
323
324 property->SetWindowType(WindowType::WINDOW_TYPE_INPUT_METHOD_FLOAT);
325 info.windowType_ = 2105;
326 sptr<SceneSession> getSceneSession3 = ssm_->CreateSceneSession(info, property);
327 ASSERT_NE(nullptr, getSceneSession3);
328 ASSERT_EQ(WindowType::WINDOW_TYPE_INPUT_METHOD_FLOAT, getSceneSession3->GetWindowType());
329
330 property->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
331 info.windowType_ = 2500;
332 sptr<SceneSession> getSceneSession4 = ssm_->CreateSceneSession(info, property);
333 ASSERT_NE(nullptr, getSceneSession4);
334 ASSERT_EQ(WindowType::SYSTEM_SUB_WINDOW_BASE, getSceneSession4->GetWindowType());
335
336 ssm_->NotifySessionUpdate(info, ActionType::SINGLE_START, 0);
337 info.persistentId_ = 0;
338 ssm_->UpdateSceneSessionWant(info);
339 info.persistentId_ = 1;
340 ssm_->UpdateSceneSessionWant(info);
341 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
342 ASSERT_NE(nullptr, sceneSession);
343 ssm_->sceneSessionMap_.insert({1, sceneSession});
344 ssm_->UpdateSceneSessionWant(info);
345 std::shared_ptr<AAFwk::Want> want = std::make_shared<AAFwk::Want>();
346 ASSERT_NE(nullptr, want);
347 info.want = want;
348 ssm_->UpdateSceneSessionWant(info);
349 sceneSession->SetCollaboratorType(0);
350 ssm_->UpdateSceneSessionWant(info);
351 sceneSession->SetCollaboratorType(1);
352 ssm_->UpdateSceneSessionWant(info);
353 ssm_->sceneSessionMap_.erase(1);
354 sptr<SceneSession> sceneSession1;
355 ssm_->UpdateCollaboratorSessionWant(sceneSession1, 1);
356 ssm_->UpdateCollaboratorSessionWant(sceneSession, 1);
357 SessionInfo info1;
358 info1.ancoSceneState = 0;
359 sceneSession1 = sptr<SceneSession>::MakeSptr(info1, nullptr);
360 ASSERT_NE(nullptr, sceneSession1);
361 ssm_->UpdateCollaboratorSessionWant(sceneSession1, 1);
362 ASSERT_EQ(CollaboratorType::DEFAULT_TYPE, sceneSession1->GetCollaboratorType());
363 }
364
365 /**
366 * @tc.name: RequestSceneSessionBackground
367 * @tc.desc: RequestSceneSessionBackground
368 * @tc.type: FUNC
369 */
370 HWTEST_F(SceneSessionManagerLifecycleTest, RequestSceneSessionBackground, Function | SmallTest | Level3)
371 {
372 sptr<SceneSession> sceneSession;
373 ssm_->RequestSceneSessionActivation(sceneSession, true);
374 SessionInfo info;
375 sptr<AAFwk::SessionInfo> abilitySessionInfo;
376 ssm_->NotifyCollaboratorAfterStart(sceneSession, abilitySessionInfo);
377 ASSERT_EQ(WSError::WS_OK, ssm_->RequestSceneSessionBackground(sceneSession, true, false));
378 ASSERT_EQ(WSError::WS_OK, ssm_->RequestSceneSessionBackground(sceneSession, true, true));
379 ASSERT_EQ(WSError::WS_OK, ssm_->RequestSceneSessionBackground(sceneSession, false, true));
380 ASSERT_EQ(WSError::WS_OK, ssm_->RequestSceneSessionBackground(sceneSession, false, false));
381 ssm_->NotifyForegroundInteractiveStatus(sceneSession, true);
382 ssm_->NotifyForegroundInteractiveStatus(sceneSession, false);
383 ssm_->DestroyDialogWithMainWindow(sceneSession);
384 sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
385 ASSERT_NE(nullptr, sceneSession);
386 ASSERT_EQ(WSError::WS_OK, ssm_->RequestSceneSessionBackground(sceneSession, true, false));
387 ASSERT_EQ(WSError::WS_OK, ssm_->RequestSceneSessionBackground(sceneSession, true, true));
388 ASSERT_EQ(WSError::WS_OK, ssm_->RequestSceneSessionBackground(sceneSession, false, true));
389 ASSERT_EQ(WSError::WS_OK, ssm_->RequestSceneSessionBackground(sceneSession, false, false));
390 ssm_->NotifyForegroundInteractiveStatus(sceneSession, true);
391 ssm_->NotifyForegroundInteractiveStatus(sceneSession, false);
392 ssm_->NotifyCollaboratorAfterStart(sceneSession, abilitySessionInfo);
393 ssm_->DestroyDialogWithMainWindow(sceneSession);
394 ssm_->DestroySubSession(sceneSession);
395 ssm_->SetAbilitySessionInfo(sceneSession);
396 ssm_->RequestSceneSessionActivation(sceneSession, true);
397 ssm_->RequestInputMethodCloseKeyboard(1);
398 ssm_->sceneSessionMap_.insert({1, nullptr});
399 ssm_->RequestInputMethodCloseKeyboard(1);
400 ssm_->RequestSceneSessionActivation(sceneSession, true);
401 ssm_->RequestSceneSessionActivation(sceneSession, false);
402 ssm_->StartUIAbilityBySCB(sceneSession);
403 ssm_->RequestSceneSessionActivation(sceneSession, true);
404 abilitySessionInfo = sptr<AAFwk::SessionInfo>::MakeSptr();
405 ASSERT_NE(nullptr, abilitySessionInfo);
406 ssm_->NotifyCollaboratorAfterStart(sceneSession, abilitySessionInfo);
407 ssm_->DestroySubSession(sceneSession);
408 ssm_->EraseSceneSessionMapById(1);
409 ASSERT_EQ(nullptr, ssm_->GetSceneSession(1));
410 }
411
412 /**
413 * @tc.name: RequestSceneSessionDestruction
414 * @tc.desc: RequestSceneSessionDestruction
415 * @tc.type: FUNC
416 */
417 HWTEST_F(SceneSessionManagerLifecycleTest, RequestSceneSessionDestruction, Function | SmallTest | Level3)
418 {
419 SessionInfo info;
420 info.abilityName_ = "111";
421 info.bundleName_ = "222";
422 sptr<SceneSession> sceneSession;
423 sptr<ISessionStage> sessionStage;
424 ssm_->AddClientDeathRecipient(sessionStage, sceneSession);
425 ssm_->RequestSceneSessionDestruction(sceneSession, true);
426 ssm_->RequestSceneSessionDestruction(sceneSession, false);
427 sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
428 ASSERT_NE(nullptr, sceneSession);
429 ssm_->AddClientDeathRecipient(sessionStage, sceneSession);
430 ssm_->RequestSceneSessionDestruction(sceneSession, true);
431 ssm_->RequestSceneSessionDestruction(sceneSession, false);
432 ssm_->sceneSessionMap_.insert({sceneSession->GetPersistentId(), sceneSession});
433 ssm_->RequestSceneSessionDestruction(sceneSession, true);
434 ssm_->RequestSceneSessionDestruction(sceneSession, false);
435 ssm_->sceneSessionMap_.erase(sceneSession->GetPersistentId());
436 sptr<AAFwk::SessionInfo> sceneSessionInfo = sptr<AAFwk::SessionInfo>::MakeSptr();
437 ASSERT_NE(nullptr, sceneSessionInfo);
438 ssm_->RequestSceneSessionDestructionInner(sceneSession, sceneSessionInfo, true);
439 ssm_->RequestSceneSessionDestructionInner(sceneSession, sceneSessionInfo, false);
440 std::shared_ptr<SessionListenerController> listenerController =
441 std::make_shared<SessionListenerController>();
442 ASSERT_NE(nullptr, listenerController);
443 ssm_->listenerController_ = listenerController;
444 ssm_->RequestSceneSessionDestructionInner(sceneSession, sceneSessionInfo, true);
445 ssm_->RequestSceneSessionDestructionInner(sceneSession, sceneSessionInfo, false);
446 ssm_->AddClientDeathRecipient(sessionStage, sceneSession);
447 ASSERT_EQ(AncoSceneState::DEFAULT_STATE, sceneSession->GetSessionInfo().ancoSceneState);
448 }
449
450 /**
451 * @tc.name: RequestSceneSessionBackground002
452 * @tc.desc: SceneSesionManager request scene session background
453 * @tc.type: FUNC
454 */
455 HWTEST_F(SceneSessionManagerLifecycleTest, RequestSceneSessionBackground002, Function | SmallTest | Level3)
456 {
457 bool isDelegator = false;
458 SessionInfo info;
459 info.abilityName_ = "RequestSceneSessionBackground002";
460 info.bundleName_ = "RequestSceneSessionBackground002";
461 sptr<SceneSession> sceneSession;
462 sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
463 ASSERT_NE(nullptr, sceneSession);
464 ASSERT_EQ(WSError::WS_OK, ssm_->RequestSceneSessionBackground(sceneSession, isDelegator));
465 }
466
467 /**
468 * @tc.name: RequestSceneSessionDestruction002
469 * @tc.desc: SceneSesionManager request scene session destruction
470 * @tc.type: FUNC
471 */
472 HWTEST_F(SceneSessionManagerLifecycleTest, RequestSceneSessionDestruction002, Function | SmallTest | Level3)
473 {
474 bool needRemoveSession = false;
475 SessionInfo info;
476 info.abilityName_ = "RequestSceneSessionDestruction002";
477 info.bundleName_ = "RequestSceneSessionDestruction002";
478 sptr<SceneSession> sceneSession;
479 sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
480 ASSERT_NE(nullptr, sceneSession);
481 ASSERT_EQ(WSError::WS_OK, ssm_->RequestSceneSessionDestruction(sceneSession, needRemoveSession));
482 }
483
484 /**
485 * @tc.name: NotifyForegroundInteractiveStatus
486 * @tc.desc: SceneSesionManager notify scene session interactive status
487 * @tc.type: FUNC
488 */
489 HWTEST_F(SceneSessionManagerLifecycleTest, NotifyForegroundInteractiveStatus, Function | SmallTest | Level3)
490 {
491 bool interactive = false;
492 SessionInfo info;
493 info.abilityName_ = "NotifyForegroundInteractiveStatus";
494 info.bundleName_ = "NotifyForegroundInteractiveStatus";
495 sptr<SceneSession> sceneSession;
496 sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
497 ASSERT_NE(nullptr, sceneSession);
498 int ret = 0;
499 ssm_->NotifyForegroundInteractiveStatus(sceneSession, interactive);
500 ASSERT_EQ(ret, 0);
501 }
502
503 /**
504 * @tc.name: NotifySessionCreate
505 * @tc.desc: SceneSesionManager notify session create
506 * @tc.type: FUNC
507 */
508 HWTEST_F(SceneSessionManagerLifecycleTest, NotifySessionCreate, Function | SmallTest | Level3)
509 {
510 SessionInfo info;
511 info.abilityName_ = "NotifySessionCreate";
512 info.bundleName_ = "NotifySessionCreate";
513 sptr<SceneSession> sceneSession;
514 sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
515 ASSERT_NE(nullptr, sceneSession);
516 ssm_->NotifySessionCreate(nullptr, info);
517 EXPECT_EQ(info.want, nullptr);
518 ssm_->NotifySessionCreate(sceneSession, info);
519 info.want = std::make_shared<AAFwk::Want>();
520 sceneSession = nullptr;
521 sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
522 ASSERT_NE(nullptr, sceneSession);
523 ssm_->NotifySessionCreate(sceneSession, info);
524 EXPECT_NE(info.want, nullptr);
525 AppExecFwk::AbilityInfo aInfo;
526 sptr<AAFwk::SessionInfo> abilitySessionInfo = sptr<AAFwk::SessionInfo>::MakeSptr();
527 std::shared_ptr<AppExecFwk::AbilityInfo> abilityInfo =
528 std::make_shared<AppExecFwk::AbilityInfo>(aInfo);
529 ASSERT_NE(nullptr, abilityInfo);
530 int32_t collaboratorType = CollaboratorType::RESERVE_TYPE;
531 ssm_->NotifyLoadAbility(collaboratorType, abilitySessionInfo, abilityInfo);
532 }
533
534 /**
535 * @tc.name: UpdateRecoveredSessionInfo
536 * @tc.desc: SceneSessionManager load window scene xml
537 * @tc.type: FUNC
538 */
539 HWTEST_F(SceneSessionManagerLifecycleTest, UpdateRecoveredSessionInfo02, Function | SmallTest | Level3)
540 {
541 std::vector<int32_t> recoveredPersistentIds;
542 ASSERT_NE(ssm_, nullptr);
543 ssm_->UpdateRecoveredSessionInfo(recoveredPersistentIds);
544 recoveredPersistentIds.push_back(0);
545 ssm_->UpdateRecoveredSessionInfo(recoveredPersistentIds);
546 SessionInfo info;
547 info.abilityName_ = "test1";
548 info.bundleName_ = "test1";
549 sptr<KeyboardSession::SpecificSessionCallback> specificCallback;
550 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, specificCallback);
551 ASSERT_NE(sceneSession, nullptr);
552 ssm_->sceneSessionMap_.insert({0, sceneSession});
553 ssm_->UpdateRecoveredSessionInfo(recoveredPersistentIds);
554 constexpr uint32_t WAIT_SYNC_IN_NS = 50000;
555 usleep(WAIT_SYNC_IN_NS);
556 }
557
558 /**
559 * @tc.name: RequestSceneSession01
560 * @tc.desc: SceneSesionManager test RequestSceneSession
561 * @tc.type: FUNC
562 */
563 HWTEST_F(SceneSessionManagerLifecycleTest, RequestSceneSession01, Function | SmallTest | Level3)
564 {
565 SessionInfo info;
566 info.abilityName_ = "RequestSceneSession01";
567 info.bundleName_ = "RequestSceneSession01";
568 info.persistentId_ = 0;
569 auto windowSessionProperty = sptr<WindowSessionProperty>::MakeSptr();
570
571 sptr<SceneSession> sceneSession = ssm_->RequestSceneSession(info, windowSessionProperty);
572 ASSERT_EQ(sceneSession, nullptr);
573 }
574
575 /**
576 * @tc.name: RequestSceneSession02
577 * @tc.desc: SceneSesionManager test RequestSceneSession
578 * @tc.type: FUNC
579 */
580 HWTEST_F(SceneSessionManagerLifecycleTest, RequestSceneSession02, Function | SmallTest | Level3)
581 {
582 SessionInfo info1;
583 info1.persistentId_ = 1;
584 info1.bundleName_ = "RequestSceneSession";
585 info1.isPersistentRecover_ = false;
586
587 auto windowSessionProperty = sptr<WindowSessionProperty>::MakeSptr();
588 SessionInfo info2;
589 info2.abilityName_ = "RequestSceneSession02";
590 info2.bundleName_ = "RequestSceneSession02";
591 info2.persistentId_ = 1;
592 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info1, nullptr);
593 ASSERT_NE(nullptr, sceneSession);
594 ssm_->sceneSessionMap_.insert({1, sceneSession});
595 sptr<SceneSession> getSceneSession = ssm_->RequestSceneSession(info2, windowSessionProperty);
596 ASSERT_NE(getSceneSession->GetSessionInfo().bundleName_, info2.bundleName_);
597 }
598
599 /**
600 * @tc.name: RequestSceneSession03
601 * @tc.desc: SceneSesionManager test RequestSceneSession
602 * @tc.type: FUNC
603 */
604 HWTEST_F(SceneSessionManagerLifecycleTest, RequestSceneSession03, Function | SmallTest | Level3)
605 {
606 SessionInfo info;
607 info.abilityName_ = "RequestSceneSession";
608 info.bundleName_ = "RequestSceneSession";
609 info.persistentId_ = 1;
610 info.isPersistentRecover_ = true;
611 auto windowSessionProperty = sptr<WindowSessionProperty>::MakeSptr();
612 auto sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
613 ASSERT_NE(sceneSession, nullptr);
614 ssm_->sceneSessionMap_.insert({1, sceneSession});
615
616 sptr<SceneSession> getSceneSession = ssm_->RequestSceneSession(info, windowSessionProperty);
617 ASSERT_EQ(getSceneSession, nullptr);
618 }
619
620 /**
621 * @tc.name: RequestSceneSession04
622 * @tc.desc: SceneSesionManager test RequestSceneSession
623 * @tc.type: FUNC
624 */
625 HWTEST_F(SceneSessionManagerLifecycleTest, RequestSceneSession04, Function | SmallTest | Level3)
626 {
627 SessionInfo info;
628 info.abilityName_ = "RequestSceneSession";
629 info.bundleName_ = "RequestSceneSession";
630 info.persistentId_ = 1;
631 info.isPersistentRecover_ = true;
632 auto windowSessionProperty = sptr<WindowSessionProperty>::MakeSptr();
633
634 sptr<SceneSession> sceneSession = ssm_->RequestSceneSession(info, windowSessionProperty);
635 ASSERT_EQ(sceneSession, nullptr);
636 }
637
638 /**
639 * @tc.name: RequestSceneSessionBackground01
640 * @tc.desc: SceneSesionManager test RequestSceneSessionBackground
641 * @tc.type: FUNC
642 */
643 HWTEST_F(SceneSessionManagerLifecycleTest, RequestSceneSessionBackground01, Function | SmallTest | Level3)
644 {
645 bool isDelegator = false;
646 bool isToDesktop = false;
647 bool isSaveSnapshot = true;
648 SessionInfo info;
649 info.abilityName_ = "RequestSceneSessionBackground";
650 info.bundleName_ = "RequestSceneSessionBackground";
651 info.persistentId_ = 1;
652 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
653 ASSERT_NE(sceneSession, nullptr);
654 ASSERT_EQ(ssm_->RequestSceneSessionBackground(
655 sceneSession, isDelegator, isToDesktop, isSaveSnapshot), WSError::WS_OK);
656 }
657
658 /**
659 * @tc.name: RequestSceneSessionBackground02
660 * @tc.desc: SceneSesionManager test RequestSceneSessionBackground
661 * @tc.type: FUNC
662 */
663 HWTEST_F(SceneSessionManagerLifecycleTest, RequestSceneSessionBackground02, Function | SmallTest | Level3)
664 {
665 bool isDelegator = false;
666 bool isToDesktop = true;
667 bool isSaveSnapshot = true;
668 SessionInfo info;
669 info.abilityName_ = "RequestSceneSessionBackground";
670 info.bundleName_ = "RequestSceneSessionBackground";
671 info.persistentId_ = 1;
672 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
673 ASSERT_NE(sceneSession, nullptr);
674 ssm_->sceneSessionMap_.insert({1, sceneSession});
675 ASSERT_EQ(ssm_->RequestSceneSessionBackground(
676 sceneSession, isDelegator, isToDesktop, isSaveSnapshot), WSError::WS_OK);
677 }
678
679 /**
680 * @tc.name: RequestSceneSessionBackground03
681 * @tc.desc: SceneSesionManager test RequestSceneSessionBackground
682 * @tc.type: FUNC
683 */
684 HWTEST_F(SceneSessionManagerLifecycleTest, RequestSceneSessionBackground03, Function | SmallTest | Level3)
685 {
686 bool isDelegator = false;
687 bool isToDesktop = true;
688 bool isSaveSnapshot = true;
689 SessionInfo info;
690 info.abilityName_ = "RequestSceneSessionBackground";
691 info.bundleName_ = "RequestSceneSessionBackground";
692 info.persistentId_ = 1;
693 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
694 ASSERT_NE(sceneSession, nullptr);
695 ssm_->sceneSessionMap_.insert({1, sceneSession});
696 ssm_->SetBrightness(sceneSession, 0.5);
697 ASSERT_EQ(ssm_->RequestSceneSessionBackground(
698 sceneSession, isDelegator, isToDesktop, isSaveSnapshot), WSError::WS_OK);
699 }
700
701 /**
702 * @tc.name: RequestSceneSessionBackground04
703 * @tc.desc: SceneSesionManager test RequestSceneSessionBackground
704 * @tc.type: FUNC
705 */
706 HWTEST_F(SceneSessionManagerLifecycleTest, RequestSceneSessionBackground04, Function | SmallTest | Level3)
707 {
708 bool isDelegator = true;
709 bool isToDesktop = true;
710 bool isSaveSnapshot = true;
711 SessionInfo info;
712 info.abilityName_ = "RequestSceneSessionBackground";
713 info.bundleName_ = "RequestSceneSessionBackground";
714 info.persistentId_ = 1;
715 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
716 ASSERT_NE(sceneSession, nullptr);
717 ssm_->sceneSessionMap_.insert({1, sceneSession});
718 ASSERT_EQ(ssm_->RequestSceneSessionBackground(
719 sceneSession, isDelegator, isToDesktop, isSaveSnapshot), WSError::WS_OK);
720 }
721
722 /**
723 * @tc.name: RequestSceneSessionDestruction01
724 * @tc.desc: SceneSesionManager test RequestSceneSessionDestruction
725 * @tc.type: FUNC
726 */
727 HWTEST_F(SceneSessionManagerLifecycleTest, RequestSceneSessionDestruction01, Function | SmallTest | Level3)
728 {
729 bool needRemoveSession = false;
730 SessionInfo info;
731 info.abilityName_ = "RequestSceneSessionDestruction";
732 info.bundleName_ = "RequestSceneSessionDestruction";
733 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
734 ASSERT_NE(sceneSession, nullptr);
735 ASSERT_EQ(ssm_->RequestSceneSessionDestruction(
736 sceneSession, needRemoveSession), WSError::WS_OK);
737 }
738
739 /**
740 * @tc.name: RequestSceneSessionDestruction02
741 * @tc.desc: SceneSesionManager test RequestSceneSessionDestruction
742 * @tc.type: FUNC
743 */
744 HWTEST_F(SceneSessionManagerLifecycleTest, RequestSceneSessionDestruction02, Function | SmallTest | Level3)
745 {
746 bool needRemoveSession = false;
747 SessionInfo info;
748 info.abilityName_ = "RequestSceneSessionDestruction";
749 info.bundleName_ = "RequestSceneSessionDestruction";
750 info.persistentId_ = 1;
751 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
752 ASSERT_NE(sceneSession, nullptr);
753 ssm_->sceneSessionMap_.insert({1, sceneSession});
754 ASSERT_EQ(ssm_->RequestSceneSessionDestruction(
755 sceneSession, needRemoveSession), WSError::WS_OK);
756 }
757
758 /**
759 * @tc.name: StartOrMinimizeUIAbilityBySCB1
760 * @tc.desc: Normal test
761 * @tc.type: FUNC
762 */
763 HWTEST_F(SceneSessionManagerLifecycleTest, StartOrMinimizeUIAbilityBySCB1, Function | SmallTest | Level3)
764 {
765 ASSERT_NE(nullptr, ssm_);
766 SessionInfo info;
767 info.abilityName_ = "StartOrMinimizeUIAbilityBySCB1";
768 info.bundleName_ = "StartOrMinimizeUIAbilityBySCB1";
769 ssm_->systemConfig_.backgroundswitch = true;
770 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
771 ASSERT_NE(nullptr, sceneSession);
772 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
773 ASSERT_NE(nullptr, property);
774 sceneSession->SetSessionProperty(property);
775 property->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
776 property->SetIsAppSupportPhoneInPc(false);
777
778 sceneSession->SetSessionState(SessionState::STATE_BACKGROUND);
779 sceneSession->SetMinimizedFlagByUserSwitch(true);
780
781 WSError ret = ssm_->StartOrMinimizeUIAbilityBySCB(sceneSession, true);
782 EXPECT_EQ(ret, WSError::WS_OK);
783 }
784
785 /**
786 * @tc.name: StartOrMinimizeUIAbilityBySCB2
787 * @tc.desc: Normal test
788 * @tc.type: FUNC
789 */
790 HWTEST_F(SceneSessionManagerLifecycleTest, StartOrMinimizeUIAbilityBySCB2, Function | SmallTest | Level3)
791 {
792 ASSERT_NE(nullptr, ssm_);
793 SessionInfo info;
794 info.abilityName_ = "StartOrMinimizeUIAbilityBySCB2";
795 info.bundleName_ = "StartOrMinimizeUIAbilityBySCB2";
796 ssm_->systemConfig_.backgroundswitch = true;
797 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
798 ASSERT_NE(nullptr, sceneSession);
799 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
800 ASSERT_NE(nullptr, property);
801 sceneSession->SetSessionProperty(property);
802 property->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
803 property->SetIsAppSupportPhoneInPc(false);
804
805 sceneSession->SetSessionState(SessionState::STATE_BACKGROUND);
806 WSError ret = ssm_->StartOrMinimizeUIAbilityBySCB(sceneSession, false);
807 EXPECT_EQ(ret, WSError::WS_OK);
808 }
809
810 /**
811 * @tc.name: RequestSceneSessionByCall01
812 * @tc.desc: SceneSesionManager test RequestSceneSessionByCall
813 * @tc.type: FUNC
814 */
815 HWTEST_F(SceneSessionManagerLifecycleTest, RequestSceneSessionByCall01, Function | SmallTest | Level3)
816 {
817 SessionInfo info;
818 info.abilityName_ = "RequestSceneSessionByCall";
819 info.bundleName_ = "RequestSceneSessionByCall";
820 info.persistentId_ = 1;
821 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
822 ASSERT_NE(sceneSession, nullptr);
823 ssm_->sceneSessionMap_.insert({1, sceneSession});
824 ASSERT_EQ(ssm_->RequestSceneSessionByCall(sceneSession), WSError::WS_OK);
825 }
826
827 /**
828 * @tc.name: RequestSceneSessionByCall02
829 * @tc.desc: SceneSesionManager test RequestSceneSessionByCall
830 * @tc.type: FUNC
831 */
832 HWTEST_F(SceneSessionManagerLifecycleTest, RequestSceneSessionByCall02, Function | SmallTest | Level3)
833 {
834 SessionInfo info;
835 info.abilityName_ = "RequestSceneSessionByCall";
836 info.bundleName_ = "RequestSceneSessionByCall";
837 info.persistentId_ = 1;
838 info.callState_ = static_cast<uint32_t>(AAFwk::CallToState::BACKGROUND);
839 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
840 ASSERT_NE(sceneSession, nullptr);
841 ssm_->sceneSessionMap_.insert({1, sceneSession});
842 ASSERT_EQ(ssm_->RequestSceneSessionByCall(sceneSession), WSError::WS_OK);
843 }
844
845 /**
846 * @tc.name: RequestSceneSessionByCall03
847 * @tc.desc: SceneSesionManager test RequestSceneSessionByCall
848 * @tc.type: FUNC
849 */
850 HWTEST_F(SceneSessionManagerLifecycleTest, RequestSceneSessionByCall03, Function | SmallTest | Level3)
851 {
852 SessionInfo info;
853 info.abilityName_ = "RequestSceneSessionByCall";
854 info.bundleName_ = "RequestSceneSessionByCall";
855 info.persistentId_ = 1;
856 info.callState_ = static_cast<uint32_t>(AAFwk::CallToState::FOREGROUND);
857 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
858 ASSERT_NE(sceneSession, nullptr);
859 ssm_->sceneSessionMap_.insert({1, sceneSession});
860 ASSERT_EQ(ssm_->RequestSceneSessionByCall(sceneSession), WSError::WS_OK);
861 }
862
863 /**
864 * @tc.name: RemoveFailRecoveredSession
865 * @tc.desc: RemoveFailRecoveredSession
866 * @tc.type: FUNC
867 */
868 HWTEST_F(SceneSessionManagerLifecycleTest, RemoveFailRecoveredSession, Function | SmallTest | Level3)
869 {
870 ASSERT_NE(nullptr, ssm_);
871 SessionInfo info;
872 info.abilityName_ = "SetBrightness";
873 sptr<SceneSession> sceneSession01 = sptr<SceneSession>::MakeSptr(info, nullptr);
874 sptr<SceneSession> sceneSession02 = sptr<SceneSession>::MakeSptr(info, nullptr);
875 ASSERT_NE(sceneSession01, nullptr);
876 ASSERT_NE(sceneSession02, nullptr);
877 ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession01));
878 ssm_->sceneSessionMap_.insert(std::make_pair(2, nullptr));
879 ssm_->sceneSessionMap_.insert(std::make_pair(3, sceneSession02));
880 ssm_->failRecoveredPersistentIdSet_.insert(1);
881 ssm_->failRecoveredPersistentIdSet_.insert(2);
882 ssm_->failRecoveredPersistentIdSet_.insert(3);
883 ssm_->RemoveFailRecoveredSession();
884 EXPECT_EQ(ssm_->failRecoveredPersistentIdSet_.size(), 0);
885 EXPECT_EQ(WSError::WS_ERROR_INVALID_SESSION, ssm_->HandleSecureSessionShouldHide(nullptr));
886 }
887
888 /**
889 * @tc.name: ClearSession
890 * @tc.desc: ClearSession
891 * @tc.type: FUNC
892 */
893 HWTEST_F(SceneSessionManagerLifecycleTest, ClearSession, Function | SmallTest | Level3)
894 {
895 ASSERT_NE(nullptr, ssm_);
896 SessionInfo info;
897 info.abilityName_ = "SetBrightness";
898 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
899 ASSERT_NE(sceneSession, nullptr);
900
901 EXPECT_EQ(WSError::WS_ERROR_INVALID_SESSION, ssm_->ClearSession(nullptr));
902 EXPECT_EQ(WSError::WS_ERROR_INVALID_SESSION, ssm_->ClearSession(sceneSession));
903 }
904
905 /**
906 * @tc.name: RegisterVisibilityChangedDetectFunc
907 * @tc.desc: RegisterVisibilityChangedDetectFunc
908 * @tc.type: FUNC
909 */
910 HWTEST_F(SceneSessionManagerLifecycleTest, RegisterVisibilityChangedDetectFunc, Function | SmallTest | Level3)
911 {
912 ASSERT_NE(nullptr, ssm_);
913 SessionInfo info;
914 info.abilityName_ = "VisibilityChanged";
915 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
916 ASSERT_NE(sceneSession, nullptr);
917
918 ssm_->RegisterVisibilityChangedDetectFunc(nullptr);
919 EXPECT_EQ(nullptr, sceneSession->visibilityChangedDetectFunc_);
920
921 ssm_->RegisterVisibilityChangedDetectFunc(sceneSession);
922 EXPECT_NE(nullptr, sceneSession->visibilityChangedDetectFunc_);
923 }
924
925 /**
926 * @tc.name: RecoveryVisibilityPidCount
927 * @tc.desc: RecoveryVisibilityPidCount
928 * @tc.type: FUNC
929 */
930 HWTEST_F(SceneSessionManagerLifecycleTest, RecoveryVisibilityPidCount, Function | SmallTest | Level3)
931 {
932 ASSERT_NE(nullptr, ssm_);
933 int32_t pid = 10;
934 SessionInfo info;
935 info.abilityName_ = "VisibilityChanged";
936 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
937 ASSERT_NE(sceneSession, nullptr);
938 ssm_->sceneSessionMap_.insert({1, sceneSession});
939 sceneSession->SetCallingPid(pid);
940
941 sptr<SceneSession> sceneSession2 = sptr<SceneSession>::MakeSptr(info, nullptr);
942 ASSERT_NE(sceneSession2, nullptr);
943 ssm_->sceneSessionMap_.insert({2, sceneSession2});
944
945 sceneSession2->SetCallingPid(pid);
946 sceneSession2->isVisible_ = true;
947
948 ssm_->RecoveryVisibilityPidCount(pid);
949 EXPECT_EQ(1, ssm_->visibleWindowCountMap_[pid]);
950 }
951
952 /**
953 * @tc.name: VisibilityChangedDetectFunc
954 * @tc.desc: VisibilityChangedDetectFunc
955 * @tc.type: FUNC
956 */
957 HWTEST_F(SceneSessionManagerLifecycleTest, VisibilityChangedDetectFunc, Function | SmallTest | Level3)
958 {
959 int32_t pid = 20;
960 SessionInfo info;
961 info.abilityName_ = "VisibilityChanged";
962 sptr<SceneSession> sceneSession1 = sptr<SceneSession>::MakeSptr(info, nullptr);
963 ASSERT_NE(sceneSession1, nullptr);
964 sptr<SceneSession> sceneSession2 = sptr<SceneSession>::MakeSptr(info, nullptr);
965 ASSERT_NE(sceneSession2, nullptr);
966 ASSERT_NE(nullptr, ssm_);
967 ssm_->RegisterVisibilityChangedDetectFunc(sceneSession1);
968 ssm_->RegisterVisibilityChangedDetectFunc(sceneSession2);
969 EXPECT_EQ(0, ssm_->visibleWindowCountMap_[pid]);
970
971 sceneSession1->visibilityChangedDetectFunc_(pid, false, true);
972 EXPECT_EQ(1, ssm_->visibleWindowCountMap_[pid]);
973
974 sceneSession2->visibilityChangedDetectFunc_(pid, false, true);
975 EXPECT_EQ(2, ssm_->visibleWindowCountMap_[pid]);
976
977 sceneSession1->visibilityChangedDetectFunc_(pid, true, false);
978 EXPECT_EQ(1, ssm_->visibleWindowCountMap_[pid]);
979
980 sceneSession2->visibilityChangedDetectFunc_(pid, true, false);
981 EXPECT_EQ(0, ssm_->visibleWindowCountMap_[pid]);
982 }
983
984 /**
985 * @tc.name: StartUIAbilityBySCBTimeoutCheck
986 * @tc.desc: StartUIAbilityBySCBTimeoutCheck
987 * @tc.type: FUNC
988 */
989 HWTEST_F(SceneSessionManagerLifecycleTest, StartUIAbilityBySCBTimeoutCheck, Function | SmallTest | Level3)
990 {
991 SessionInfo sessionInfo;
992 sessionInfo.bundleName_ = "accessibilityNotifyTesterBundleName";
993 sessionInfo.abilityName_ = "accessibilityNotifyTesterAbilityName";
994 sessionInfo.ancoSceneState = AncoSceneState::NOTIFY_FOREGROUND;
995 ASSERT_NE(ssm_, nullptr);
996 sptr<SceneSession> sceneSession = ssm_->CreateSceneSession(sessionInfo, nullptr);
997 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
998 ASSERT_NE(property, nullptr);
999 property->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1000 sceneSession->SetSessionProperty(property);
1001 sceneSession->SetScbCoreEnabled(true);
1002 sptr<AAFwk::SessionInfo> abilitySessionInfo = ssm_->SetAbilitySessionInfo(sceneSession);
1003 ASSERT_NE(abilitySessionInfo, nullptr);
1004 bool isColdStart = true;
1005 ASSERT_EQ(ssm_->StartUIAbilityBySCBTimeoutCheck(abilitySessionInfo,
1006 static_cast<uint32_t>(WindowStateChangeReason::ABILITY_CALL), isColdStart), 2097202);
1007 ASSERT_EQ(ssm_->StartUIAbilityBySCBTimeoutCheck(abilitySessionInfo,
1008 static_cast<uint32_t>(WindowStateChangeReason::USER_SWITCH), isColdStart), 2097202);
1009 }
1010
1011 /**
1012 * @tc.name: SubmitTaskAndWait
1013 * @tc.desc: SubmitTaskAndWait
1014 * @tc.type: FUNC
1015 */
1016 HWTEST_F(SceneSessionManagerLifecycleTest, SubmitTaskAndWait, Function | SmallTest | Level3)
1017 {
1018 uint64_t timeout = 3000;
1019 auto ffrtQueueHelper = std::make_shared<FfrtQueueHelper>();
1020 ASSERT_NE(ffrtQueueHelper, nullptr);
__anonc9db8fb30302() 1021 auto timeoutTask = []() {
1022 std::cout << "===enter timeoutTask begin sleep 4 sec===" << std::endl;
1023 std::this_thread::sleep_for(std::chrono::seconds(4));
1024 };
1025 ASSERT_EQ(ffrtQueueHelper->SubmitTaskAndWait(std::move(timeoutTask), timeout), true);
__anonc9db8fb30402() 1026 auto task = []() {
1027 std::cout << "===enter task begin sleep 1 sec===" << std::endl;
1028 std::this_thread::sleep_for(std::chrono::seconds(1));
1029 };
1030 ASSERT_EQ(ffrtQueueHelper->SubmitTaskAndWait(std::move(task), timeout), false);
1031 }
1032 }
1033 } // namespace Rosen
1034 } // namespace OHOS
1035