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
18 #include "multi_screen_manager.h"
19 #include "screen_session_manager/include/screen_session_manager.h"
20 #include "display_manager_agent_default.h"
21 #include "common_test_utils.h"
22 #include "modifier_render_thread/rs_modifiers_draw_thread.h"
23 #include "test_client.h"
24
25 using namespace testing;
26 using namespace testing::ext;
27
28 namespace OHOS {
29 namespace Rosen {
30 namespace {
31 constexpr uint32_t SLEEP_TIME_IN_US = 100000; // 100ms
32 }
33 class MultiScreenManagerTest : public testing::Test {
34 public:
35 static void SetUpTestCase();
36 static void TearDownTestCase();
37 void SetUp() override;
38 void TearDown() override;
39 sptr<ScreenSessionManagerClientTest> testClient_;
40 void SetAceessTokenPermission(const std::string processName);
41 };
42
SetUpTestCase()43 void MultiScreenManagerTest::SetUpTestCase()
44 {
45 CommonTestUtils::InjectTokenInfoByHapName(0, "com.ohos.systemui", 0);
46 const char** perms = new const char *[1];
47 perms[0] = "ohos.permission.CAPTURE_SCREEN";
48 CommonTestUtils::SetAceessTokenPermission("foundation", perms, 1);
49 }
50
TearDownTestCase()51 void MultiScreenManagerTest::TearDownTestCase()
52 {
53 #ifdef RS_ENABLE_VK
54 RSModifiersDrawThread::Destroy();
55 #endif
56 usleep(SLEEP_TIME_IN_US);
57 }
58
SetUp()59 void MultiScreenManagerTest::SetUp()
60 {
61 }
62
TearDown()63 void MultiScreenManagerTest::TearDown()
64 {
65 }
66
67 namespace {
68
69 /**
70 * @tc.name: FilterPhysicalAndVirtualScreen
71 * @tc.desc: FilterPhysicalAndVirtualScreen func
72 * @tc.type: FUNC
73 */
74 HWTEST_F(MultiScreenManagerTest, FilterPhysicalAndVirtualScreen, TestSize.Level1)
75 {
76 std::vector<ScreenId> allScreenIds = {2000, 2001, 0};
77 std::vector<ScreenId> physicalScreenIds;
78 std::vector<ScreenId> virtualScreenIds;
79 MultiScreenManager::GetInstance().FilterPhysicalAndVirtualScreen(allScreenIds,
80 physicalScreenIds, virtualScreenIds);
81 EXPECT_EQ(virtualScreenIds.size(), 0);
82 }
83
84 /**
85 * @tc.name: VirtualScreenMirrorSwitch
86 * @tc.desc: VirtualScreenMirrorSwitch func
87 * @tc.type: FUNC
88 */
89 HWTEST_F(MultiScreenManagerTest, VirtualScreenMirrorSwitch01, TestSize.Level1)
90 {
91 ScreenId mainScreenId = 1;
92 std::vector<ScreenId> ScreenIds = {2, 3};
93 ScreenId screenGroupId;
94 MultiScreenManager::GetInstance().VirtualScreenMirrorSwitch(mainScreenId, ScreenIds, DMRect::NONE(),
95 screenGroupId);
96 EXPECT_EQ(screenGroupId, 0);
97 }
98
99 /**
100 * @tc.name: VirtualScreenMirrorSwitch
101 * @tc.desc: mainScreen is not nullptr
102 * @tc.type: FUNC
103 */
104 HWTEST_F(MultiScreenManagerTest, VirtualScreenMirrorSwitch02, TestSize.Level1)
105 {
106 ScreenId mainScreenId = 1002;
107 std::vector<ScreenId> ScreenIds = {2, 3};
108 ScreenId screenGroupId;
109 sptr<ScreenSession> session = new ScreenSession();
110 ScreenSessionManager::GetInstance().screenSessionMap_[mainScreenId] = session;
111 auto ret = MultiScreenManager::GetInstance().VirtualScreenMirrorSwitch(mainScreenId, ScreenIds,
112 DMRect::NONE(), screenGroupId);
113 EXPECT_EQ(ret, DMError::DM_OK);
114 }
115
116 /**
117 * @tc.name: VirtualScreenMirrorSwitch
118 * @tc.desc: ret != DMError::DM_OK
119 * @tc.type: FUNC
120 */
121 HWTEST_F(MultiScreenManagerTest, VirtualScreenMirrorSwitch03, TestSize.Level1)
122 {
123 ScreenId mainScreenId = 1002;
124 std::vector<ScreenId> ScreenIds = {2, 3};
125 ScreenId screenGroupId;
126 sptr<ScreenSession> session = new ScreenSession();
127 ScreenSessionManager::GetInstance().screenSessionMap_[mainScreenId] = session;
128 ScreenId rsId = 1002;
129 std::string name = "ok";
130 ScreenCombination combination = ScreenCombination::SCREEN_ALONE;
131 sptr<ScreenSessionGroup> sessiongroup = new ScreenSessionGroup(mainScreenId, rsId, name, combination);
132 ScreenSessionManager::GetInstance().smsScreenGroupMap_[mainScreenId] = sessiongroup;
133 auto ret = MultiScreenManager::GetInstance().VirtualScreenMirrorSwitch(mainScreenId, ScreenIds, DMRect::NONE(),
134 screenGroupId);
135 EXPECT_EQ(ret, DMError::DM_OK);
136 }
137
138 /**
139 * @tc.name: VirtualScreenMirrorSwitch04
140 * @tc.desc: VirtualScreenMirrorSwitch func04
141 * @tc.type: FUNC
142 */
143 HWTEST_F(MultiScreenManagerTest, VirtualScreenMirrorSwitch04, TestSize.Level1)
144 {
145 ScreenId mainScreenId = 1003;
146 std::vector<ScreenId> ScreenIds = {2, 3};
147 ScreenId screenGroupId;
148 MultiScreenManager::GetInstance().VirtualScreenMirrorSwitch(mainScreenId, ScreenIds, DMRect::NONE(),
149 screenGroupId);
150 EXPECT_EQ(screenGroupId, 0);
151 }
152
153 /**
154 * @tc.name: VirtualScreenMirrorSwitch05
155 * @tc.desc: VirtualScreenMirrorSwitch func05
156 * @tc.type: FUNC
157 */
158 HWTEST_F(MultiScreenManagerTest, VirtualScreenMirrorSwitch05, TestSize.Level1)
159 {
160 ScreenId mainScreenId = 101;
161 std::vector<ScreenId> ScreenIds = {1, 2};
162 ScreenId screenGroupId;
163 MultiScreenManager::GetInstance().VirtualScreenMirrorSwitch(mainScreenId, ScreenIds, DMRect::NONE(),
164 screenGroupId);
165 EXPECT_EQ(screenGroupId, 0);
166 }
167
168 /**
169 * @tc.name: VirtualScreenMirrorSwitch06
170 * @tc.desc: VirtualScreenMirrorSwitch func06
171 * @tc.type: FUNC
172 */
173 HWTEST_F(MultiScreenManagerTest, VirtualScreenMirrorSwitch06, TestSize.Level1)
174 {
175 ScreenId mainScreenId = 102;
176 std::vector<ScreenId> ScreenIds = {1, 3};
177 ScreenId screenGroupId;
178 MultiScreenManager::GetInstance().VirtualScreenMirrorSwitch(mainScreenId, ScreenIds, DMRect::NONE(),
179 screenGroupId);
180 EXPECT_EQ(screenGroupId, 0);
181 }
182
183 /**
184 * @tc.name: VirtualScreenMirrorSwitch
185 * @tc.desc: VirtualScreenMirrorSwitch func DMRect not null
186 * @tc.type: FUNC
187 */
188 HWTEST_F(MultiScreenManagerTest, VirtualScreenMirrorSwitch07, TestSize.Level1)
189 {
190 ScreenId mainScreenId = 1;
191 std::vector<ScreenId> ScreenIds = {2, 3};
192 ScreenId screenGroupId;
193 DMRect myRect = {0, 0, 400, 600};
194 MultiScreenManager::GetInstance().VirtualScreenMirrorSwitch(mainScreenId, ScreenIds, myRect,
195 screenGroupId);
196 EXPECT_EQ(screenGroupId, 0);
197 }
198
199 /**
200 * @tc.name: VirtualScreenMirrorSwitch
201 * @tc.desc: mainScreen is not nullptr and DMRect not null
202 * @tc.type: FUNC
203 */
204 HWTEST_F(MultiScreenManagerTest, VirtualScreenMirrorSwitch08, TestSize.Level1)
205 {
206 ScreenId mainScreenId = 1002;
207 std::vector<ScreenId> ScreenIds = {2, 3};
208 ScreenId screenGroupId;
209 sptr<ScreenSession> session = new ScreenSession();
210 DMRect myRect = {0, 0, 400, 600};
211 ScreenSessionManager::GetInstance().screenSessionMap_[mainScreenId] = session;
212 auto ret = MultiScreenManager::GetInstance().VirtualScreenMirrorSwitch(mainScreenId, ScreenIds,
213 myRect, screenGroupId);
214 EXPECT_EQ(ret, DMError::DM_OK);
215 }
216
217 /**
218 * @tc.name: VirtualScreenMirrorSwitch
219 * @tc.desc: ret != DMError::DM_OK and DMRect not null
220 * @tc.type: FUNC
221 */
222 HWTEST_F(MultiScreenManagerTest, VirtualScreenMirrorSwitch09, TestSize.Level1)
223 {
224 ScreenId mainScreenId = 1002;
225 std::vector<ScreenId> ScreenIds = {2, 3};
226 ScreenId screenGroupId;
227 sptr<ScreenSession> session = new ScreenSession();
228 ScreenSessionManager::GetInstance().screenSessionMap_[mainScreenId] = session;
229 ScreenId rsId = 1002;
230 std::string name = "ok";
231 DMRect myRect = {0, 0, 400, 600};
232 ScreenCombination combination = ScreenCombination::SCREEN_ALONE;
233 sptr<ScreenSessionGroup> sessiongroup = new ScreenSessionGroup(mainScreenId, rsId, name, combination);
234 ScreenSessionManager::GetInstance().smsScreenGroupMap_[mainScreenId] = sessiongroup;
235 auto ret = MultiScreenManager::GetInstance().VirtualScreenMirrorSwitch(mainScreenId, ScreenIds, myRect,
236 screenGroupId);
237 EXPECT_EQ(ret, DMError::DM_OK);
238 }
239
240 /**
241 * @tc.name: PhysicalScreenMirrorSwitch
242 * @tc.desc: PhysicalScreenMirrorSwitch func
243 * @tc.type: FUNC
244 */
245 HWTEST_F(MultiScreenManagerTest, PhysicalScreenMirrorSwitch01, TestSize.Level1)
246 {
247 std::vector<ScreenId> screenIds = {2, 3};
248 DMError ret = MultiScreenManager::GetInstance().PhysicalScreenMirrorSwitch(screenIds, DMRect::NONE());
249 EXPECT_EQ(ret, DMError::DM_ERROR_NULLPTR);
250 }
251
252 /**
253 * @tc.name: PhysicalScreenMirrorSwitch
254 * @tc.desc: defaultSession != nullptr
255 * @tc.type: FUNC
256 */
257 HWTEST_F(MultiScreenManagerTest, PhysicalScreenMirrorSwitch02, TestSize.Level1)
258 {
259 std::vector<ScreenId> screenIds = {1002, 1003};
260 sptr<ScreenSession> session = new ScreenSession();
261 ScreenSessionManager::GetInstance().screenSessionMap_[
262 ScreenSessionManager::GetInstance().defaultScreenId_] = session;
263 DMError ret = MultiScreenManager::GetInstance().PhysicalScreenMirrorSwitch(screenIds, DMRect::NONE());
264 EXPECT_EQ(ret, DMError::DM_OK);
265 }
266
267 /**
268 * @tc.name: PhysicalScreenMirrorSwitch
269 * @tc.desc: defaultSession != nullptr
270 * @tc.type: FUNC
271 */
272 HWTEST_F(MultiScreenManagerTest, PhysicalScreenMirrorSwitch03, TestSize.Level1)
273 {
274 std::vector<ScreenId> screenIds = {1002, 1003};
275 sptr<ScreenSession> session = new ScreenSession();
276 ScreenSessionManager::GetInstance().screenSessionMap_[
277 ScreenSessionManager::GetInstance().defaultScreenId_] = session;
278 sptr<ScreenSession> session1 = new ScreenSession();
279 ScreenSessionManager::GetInstance().screenSessionMap_[1002] = session1;
280 DMError ret = MultiScreenManager::GetInstance().PhysicalScreenMirrorSwitch(screenIds, DMRect::NONE());
281 EXPECT_EQ(ret, DMError::DM_OK);
282 }
283
284 /**
285 * @tc.name: PhysicalScreenMirrorSwitch04
286 * @tc.desc: defaultSession != nullptr
287 * @tc.type: FUNC
288 */
289 HWTEST_F(MultiScreenManagerTest, PhysicalScreenMirrorSwitch04, TestSize.Level1)
290 {
291 std::vector<ScreenId> screenIds = {101, 102};
292 sptr<ScreenSession> session = new ScreenSession();
293 ScreenSessionManager::GetInstance().screenSessionMap_[
294 ScreenSessionManager::GetInstance().defaultScreenId_] = session;
295 DMError ret = MultiScreenManager::GetInstance().PhysicalScreenMirrorSwitch(screenIds, DMRect::NONE());
296 EXPECT_EQ(ret, DMError::DM_OK);
297 }
298
299 /**
300 * @tc.name: PhysicalScreenMirrorSwitch05
301 * @tc.desc: defaultSession != nullptr
302 * @tc.type: FUNC
303 */
304 HWTEST_F(MultiScreenManagerTest, PhysicalScreenMirrorSwitch05, TestSize.Level1)
305 {
306 std::vector<ScreenId> screenIds = {12, 13};
307 sptr<ScreenSession> session = new ScreenSession();
308 ScreenSessionManager::GetInstance().screenSessionMap_[
309 ScreenSessionManager::GetInstance().defaultScreenId_] = session;
310 sptr<ScreenSession> session1 = new ScreenSession();
311 ScreenSessionManager::GetInstance().screenSessionMap_[12] = session1;
312 DMError ret = MultiScreenManager::GetInstance().PhysicalScreenMirrorSwitch(screenIds, DMRect::NONE());
313 EXPECT_EQ(ret, DMError::DM_OK);
314 }
315
316 /**
317 * @tc.name: PhysicalScreenMirrorSwitch06
318 * @tc.desc: and DMRect not null
319 * @tc.type: FUNC
320 */
321 HWTEST_F(MultiScreenManagerTest, PhysicalScreenMirrorSwitch06, TestSize.Level1)
322 {
323 std::vector<ScreenId> screenIds = {2, 3};
324 DMRect myRect = {0, 0, 400, 600};
325 DMError ret = MultiScreenManager::GetInstance().PhysicalScreenMirrorSwitch(screenIds, myRect);
326 EXPECT_NE(ret, DMError::DM_ERROR_NULLPTR);
327 }
328
329 /**
330 * @tc.name: PhysicalScreenMirrorSwitch07
331 * @tc.desc: defaultSession != nullptr and DMRect not null
332 * @tc.type: FUNC
333 */
334 HWTEST_F(MultiScreenManagerTest, PhysicalScreenMirrorSwitch07, TestSize.Level1)
335 {
336 std::vector<ScreenId> screenIds = {1002, 1003};
337 sptr<ScreenSession> session = new ScreenSession();
338 DMRect myRect = {0, 0, 400, 600};
339 ScreenSessionManager::GetInstance().screenSessionMap_[
340 ScreenSessionManager::GetInstance().defaultScreenId_] = session;
341 DMError ret = MultiScreenManager::GetInstance().PhysicalScreenMirrorSwitch(screenIds, myRect);
342 EXPECT_EQ(ret, DMError::DM_OK);
343 }
344
345 /**
346 * @tc.name: PhysicalScreenMirrorSwitch08
347 * @tc.desc: defaultSession != nullptr and DMRect not null
348 * @tc.type: FUNC
349 */
350 HWTEST_F(MultiScreenManagerTest, PhysicalScreenMirrorSwitch08, TestSize.Level1)
351 {
352 std::vector<ScreenId> screenIds = {1002, 1003};
353 sptr<ScreenSession> session = new ScreenSession();
354 DMRect myRect = {0, 0, 400, 600};
355 ScreenSessionManager::GetInstance().screenSessionMap_[
356 ScreenSessionManager::GetInstance().defaultScreenId_] = session;
357 sptr<ScreenSession> session1 = new ScreenSession();
358 ScreenSessionManager::GetInstance().screenSessionMap_[1002] = session1;
359 DMError ret = MultiScreenManager::GetInstance().PhysicalScreenMirrorSwitch(screenIds, myRect);
360 EXPECT_EQ(ret, DMError::DM_OK);
361 }
362
363 /**
364 * @tc.name: PhysicalScreenMirrorSwitch09
365 * @tc.desc: defaultSession != nullptr and DMRect not null
366 * @tc.type: FUNC
367 */
368 HWTEST_F(MultiScreenManagerTest, PhysicalScreenMirrorSwitch09, TestSize.Level1)
369 {
370 std::vector<ScreenId> screenIds = {101, 102};
371 sptr<ScreenSession> session = new ScreenSession();
372 DMRect myRect = {0, 0, 400, 600};
373 ScreenSessionManager::GetInstance().screenSessionMap_[
374 ScreenSessionManager::GetInstance().defaultScreenId_] = session;
375 DMError ret = MultiScreenManager::GetInstance().PhysicalScreenMirrorSwitch(screenIds, myRect);
376 EXPECT_EQ(ret, DMError::DM_OK);
377 }
378
379
380 /**
381 * @tc.name: PhysicalScreenMirrorSwitch10
382 * @tc.desc: defaultSession != nullptr and DMRect not null
383 * @tc.type: FUNC
384 */
385 HWTEST_F(MultiScreenManagerTest, PhysicalScreenMirrorSwitch10, TestSize.Level1)
386 {
387 std::vector<ScreenId> screenIds = {12, 13};
388 sptr<ScreenSession> session = new ScreenSession();
389 ScreenSessionManager::GetInstance().screenSessionMap_[
390 ScreenSessionManager::GetInstance().defaultScreenId_] = session;
391 sptr<ScreenSession> session1 = new ScreenSession();
392 DMRect myRect = {0, 0, 400, 600};
393 ScreenSessionManager::GetInstance().screenSessionMap_[12] = session1;
394 DMError ret = MultiScreenManager::GetInstance().PhysicalScreenMirrorSwitch(screenIds, myRect);
395 EXPECT_EQ(ret, DMError::DM_OK);
396 }
397
398
399 /**
400 * @tc.name: PhysicalScreenUniqueSwitch
401 * @tc.desc: PhysicalScreenUniqueSwitch func
402 * @tc.type: FUNC
403 */
404 HWTEST_F(MultiScreenManagerTest, PhysicalScreenUniqueSwitch, TestSize.Level1)
405 {
406 std::vector<ScreenId> screenIds = {2, 3};
407 DMError ret = MultiScreenManager::GetInstance().PhysicalScreenUniqueSwitch(screenIds);
408 EXPECT_EQ(ret, DMError::DM_OK);
409 }
410
411 /**
412 * @tc.name: PhysicalScreenUniqueSwitch01
413 * @tc.desc: PhysicalScreenUniqueSwitch func
414 * @tc.type: FUNC
415 */
416 HWTEST_F(MultiScreenManagerTest, PhysicalScreenUniqueSwitch01, TestSize.Level1)
417 {
418 std::vector<ScreenId> screenIds = {1002, 1003};
419 DMError ret = MultiScreenManager::GetInstance().PhysicalScreenUniqueSwitch(screenIds);
420 EXPECT_EQ(ret, DMError::DM_OK);
421 }
422
423 /**
424 * @tc.name: PhysicalScreenUniqueSwitch02
425 * @tc.desc: screenSession != nullptr
426 * @tc.type: FUNC
427 */
428 HWTEST_F(MultiScreenManagerTest, PhysicalScreenUniqueSwitch02, TestSize.Level1)
429 {
430 std::vector<ScreenId> screenIds = {1002, 1003};
431 sptr<ScreenSession> session = new ScreenSession();
432 ScreenSessionManager::GetInstance().screenSessionMap_[
433 1002] = session;
434 sptr<ScreenSession> session1 = new ScreenSession();
435 ScreenSessionManager::GetInstance().screenSessionMap_[
436 1003] = session1;
437 DMError ret = MultiScreenManager::GetInstance().PhysicalScreenUniqueSwitch(screenIds);
438 EXPECT_EQ(ret, DMError::DM_OK);
439 }
440
441 /**
442 * @tc.name: PhysicalScreenUniqueSwitch03
443 * @tc.desc: screenSession != nullptr
444 * @tc.type: FUNC
445 */
446 HWTEST_F(MultiScreenManagerTest, PhysicalScreenUniqueSwitch03, TestSize.Level1)
447 {
448 std::vector<ScreenId> screenIds = {1002, 1003};
449 sptr<ScreenSession> session = nullptr;
450 ScreenSessionManager::GetInstance().screenSessionMap_[
451 1002] = session;
452 sptr<ScreenSession> session1 = new ScreenSession();
453 ScreenSessionManager::GetInstance().screenSessionMap_[
454 1003] = session1;
455 DMError ret = MultiScreenManager::GetInstance().PhysicalScreenUniqueSwitch(screenIds);
456 EXPECT_EQ(ret, DMError::DM_OK);
457 }
458
459 /**
460 * @tc.name: PhysicalScreenUniqueSwitch04
461 * @tc.desc: screenSession != nullptr
462 * @tc.type: FUNC
463 */
464 HWTEST_F(MultiScreenManagerTest, PhysicalScreenUniqueSwitch04, TestSize.Level1)
465 {
466 std::vector<ScreenId> screenIds = {2, 3};
467 sptr<ScreenSession> session = new ScreenSession();
468 ScreenSessionManager::GetInstance().screenSessionMap_[
469 1002] = session;
470 sptr<ScreenSession> session1 = new ScreenSession();
471 ScreenSessionManager::GetInstance().screenSessionMap_[
472 1003] = session1;
473 DMError ret = MultiScreenManager::GetInstance().PhysicalScreenUniqueSwitch(screenIds);
474 EXPECT_EQ(ret, DMError::DM_OK);
475 }
476
477 /**
478 * @tc.name: PhysicalScreenUniqueSwitch_CustomScbScreenCreate
479 * @tc.desc: screenSession != nullptr
480 * @tc.type: FUNC
481 */
482 HWTEST_F(MultiScreenManagerTest, PhysicalScreenUniqueSwitch05, TestSize.Level1)
483 {
484 std::vector<ScreenId> screenIds = {1002, 1003};
485 sptr<ScreenSession> session = new ScreenSession();
486 session->SetInnerName("CustomScbScreen");
487 ScreenSessionManager::GetInstance().screenSessionMap_[
488 1002] = session;
489 sptr<ScreenSession> session1 = new ScreenSession();
490 session->SetInnerName("UNKOWN");
491 ScreenSessionManager::GetInstance().screenSessionMap_[
492 1003] = session1;
493 DMError ret = MultiScreenManager::GetInstance().PhysicalScreenUniqueSwitch(screenIds);
494 EXPECT_EQ(ret, DMError::DM_OK);
495 }
496
497 /**
498 * @tc.name: VirtualScreenUniqueSwitch01
499 * @tc.desc: VirtualScreenUniqueSwitch func
500 * @tc.type: FUNC
501 */
502 HWTEST_F(MultiScreenManagerTest, VirtualScreenUniqueSwitch01, TestSize.Level1)
503 {
504 sptr<ScreenSession> screenSession =new ScreenSession();
505 std::vector<ScreenId> screenIds = {2, 3};
506 DMError ret = MultiScreenManager::GetInstance().VirtualScreenUniqueSwitch(screenSession, screenIds);
507 EXPECT_EQ(ret, DMError::DM_ERROR_NULLPTR);
508 }
509
510 /**
511 * @tc.name: VirtualScreenUniqueSwitch02
512 * @tc.desc: VirtualScreenUniqueSwitch func
513 * @tc.type: FUNC
514 */
515 HWTEST_F(MultiScreenManagerTest, VirtualScreenUniqueSwitch02, TestSize.Level1)
516 {
517 sptr<ScreenSession> screenSession =nullptr;
518 std::vector<ScreenId> screenIds = {2, 3};
519 DMError ret = MultiScreenManager::GetInstance().VirtualScreenUniqueSwitch(screenSession, screenIds);
520 EXPECT_EQ(ret, DMError::DM_ERROR_NULLPTR);
521 }
522
523 /**
524 * @tc.name: VirtualScreenUniqueSwitch
525 * @tc.desc: VirtualScreenUniqueSwitch func
526 * @tc.type: FUNC
527 */
528 HWTEST_F(MultiScreenManagerTest, VirtualScreenUniqueSwitch03, TestSize.Level1)
529 {
530 sptr<ScreenSession> screenSession =nullptr;
531 std::vector<ScreenId> screenIds = {1012, 1002};
532 DMError ret = MultiScreenManager::GetInstance().VirtualScreenUniqueSwitch(screenSession, screenIds);
533 EXPECT_EQ(ret, DMError::DM_ERROR_NULLPTR);
534 }
535
536 /**
537 * @tc.name: VirtualScreenUniqueSwitch
538 * @tc.desc: VirtualScreenUniqueSwitch func
539 * @tc.type: FUNC
540 */
541 HWTEST_F(MultiScreenManagerTest, VirtualScreenUniqueSwitch04, TestSize.Level1)
542 {
543 sptr<ScreenSession> screenSession =nullptr;
544 std::vector<ScreenId> screenIds = {12, 1001};
545 DMError ret = MultiScreenManager::GetInstance().VirtualScreenUniqueSwitch(screenSession, screenIds);
546 EXPECT_EQ(ret, DMError::DM_ERROR_NULLPTR);
547 }
548
549 /**
550 * @tc.name: VirtualScreenUniqueSwitch
551 * @tc.desc: VirtualScreenUniqueSwitch func
552 * @tc.type: FUNC
553 */
554 HWTEST_F(MultiScreenManagerTest, VirtualScreenUniqueSwitch05, TestSize.Level1)
555 {
556 sptr<ScreenSession> screenSession =nullptr;
557 std::vector<ScreenId> screenIds = {12, 1002};
558 DMError ret = MultiScreenManager::GetInstance().VirtualScreenUniqueSwitch(screenSession, screenIds);
559 EXPECT_EQ(ret, DMError::DM_ERROR_NULLPTR);
560 }
561
562 /**
563 * @tc.name: VirtualScreenUniqueSwitch
564 * @tc.desc: VirtualScreenUniqueSwitch func
565 * @tc.type: FUNC
566 */
567 HWTEST_F(MultiScreenManagerTest, VirtualScreenUniqueSwitch06, TestSize.Level1)
568 {
569 sptr<ScreenSession> screenSession =nullptr;
570 std::vector<ScreenId> screenIds = {12, 1003};
571 DMError ret = MultiScreenManager::GetInstance().VirtualScreenUniqueSwitch(screenSession, screenIds);
572 EXPECT_EQ(ret, DMError::DM_ERROR_NULLPTR);
573 }
574
575 /**
576 * @tc.name: VirtualScreenUniqueSwitch
577 * @tc.desc: VirtualScreenUniqueSwitch func
578 * @tc.type: FUNC
579 */
580 HWTEST_F(MultiScreenManagerTest, VirtualScreenUniqueSwitch07, TestSize.Level1)
581 {
582 sptr<ScreenSession> screenSession =nullptr;
583 std::vector<ScreenId> screenIds = {1003, 1003};
584 DMError ret = MultiScreenManager::GetInstance().VirtualScreenUniqueSwitch(screenSession, screenIds);
585 EXPECT_EQ(ret, DMError::DM_ERROR_NULLPTR);
586 }
587
588 /**
589 * @tc.name: VirtualScreenUniqueSwitch
590 * @tc.desc: VirtualScreenUniqueSwitch func
591 * @tc.type: FUNC
592 */
593 HWTEST_F(MultiScreenManagerTest, VirtualScreenUniqueSwitch08, TestSize.Level1)
594 {
595 sptr<ScreenSession> screenSession =nullptr;
596 std::vector<ScreenId> screenIds = {1003, 1002};
597 DMError ret = MultiScreenManager::GetInstance().VirtualScreenUniqueSwitch(screenSession, screenIds);
598 EXPECT_EQ(ret, DMError::DM_ERROR_NULLPTR);
599 }
600
601 /**
602 * @tc.name: VirtualScreenUniqueSwitch
603 * @tc.desc: VirtualScreenUniqueSwitch func
604 * @tc.type: FUNC
605 */
606 HWTEST_F(MultiScreenManagerTest, VirtualScreenUniqueSwitch09, TestSize.Level1)
607 {
608 sptr<ScreenSession> screenSession =nullptr;
609 std::vector<ScreenId> screenIds = {1003, 1001};
610 DMError ret = MultiScreenManager::GetInstance().VirtualScreenUniqueSwitch(screenSession, screenIds);
611 EXPECT_EQ(ret, DMError::DM_ERROR_NULLPTR);
612 }
613
614 /**
615 * @tc.name: VirtualScreenUniqueSwitch
616 * @tc.desc: VirtualScreenUniqueSwitch func
617 * @tc.type: FUNC
618 */
619 HWTEST_F(MultiScreenManagerTest, VirtualScreenUniqueSwitch010, TestSize.Level1)
620 {
621 sptr<ScreenSession> screenSession =nullptr;
622 std::vector<ScreenId> screenIds = {1004, 1001};
623 DMError ret = MultiScreenManager::GetInstance().VirtualScreenUniqueSwitch(screenSession, screenIds);
624 EXPECT_EQ(ret, DMError::DM_ERROR_NULLPTR);
625 }
626
627 /**
628 * @tc.name: VirtualScreenUniqueSwitch11
629 * @tc.desc: VirtualScreenUniqueSwitch func
630 * @tc.type: FUNC
631 */
632 HWTEST_F(MultiScreenManagerTest, VirtualScreenUniqueSwitch11, TestSize.Level1)
633 {
634 sptr<ScreenSession> screenSession = new ScreenSession();
635 std::vector<ScreenId> screenIds = {1003, 11};
636 DMError ret = MultiScreenManager::GetInstance().VirtualScreenUniqueSwitch(screenSession, screenIds);
637 EXPECT_EQ(ret, DMError::DM_ERROR_NULLPTR);
638 }
639
640 /**
641 * @tc.name: VirtualScreenUniqueSwitch12
642 * @tc.desc: VirtualScreenUniqueSwitch func
643 * @tc.type: FUNC
644 */
645 HWTEST_F(MultiScreenManagerTest, VirtualScreenUniqueSwitch12, TestSize.Level1)
646 {
647 sptr<ScreenSession> screenSession = new ScreenSession();
648 std::vector<ScreenId> screenIds = {1004, 1001};
649 DMError ret = MultiScreenManager::GetInstance().VirtualScreenUniqueSwitch(screenSession, screenIds);
650 EXPECT_EQ(ret, DMError::DM_ERROR_NULLPTR);
651 }
652
653 /**
654 * @tc.name: VirtualScreenUniqueSwitch13
655 * @tc.desc: VirtualScreenUniqueSwitch func
656 * @tc.type: FUNC
657 */
658 HWTEST_F(MultiScreenManagerTest, VirtualScreenUniqueSwitch13, TestSize.Level1)
659 {
660 std::vector<ScreenId> screenIds = {1002};
661 sptr<ScreenSession> screenSession = new ScreenSession();
662 screenSession->SetInnerName("CustomScbScreen");
663 ScreenSessionManager::GetInstance().screenSessionMap_[
664 1002] = screenSession;
665 DMError ret = MultiScreenManager::GetInstance().VirtualScreenUniqueSwitch(screenSession, screenIds);
666 EXPECT_EQ(ret, DMError::DM_ERROR_NULLPTR);
667 }
668
669 /**
670 * @tc.name: NotifyScreenConnectCompletion01
671 * @tc.desc: NotifyScreenConnectCompletion func
672 * @tc.type: FUNC
673 */
674 HWTEST_F(MultiScreenManagerTest, NotifyScreenConnectCompletion01, TestSize.Level1)
675 {
676 MultiScreenManager::GetInstance().uniqueScreenTimeoutMap_.clear();
677 MultiScreenManager::GetInstance().uniqueScreenTimeoutMap_[1100] = false;
678 MultiScreenManager::GetInstance().NotifyScreenConnectCompletion(1100);
679 EXPECT_EQ(MultiScreenManager::GetInstance().uniqueScreenTimeoutMap_[1100], true);
680 }
681
682 /**
683 * @tc.name: UniqueSwitch
684 * @tc.desc: UniqueSwitch func
685 * @tc.type: FUNC
686 */
687 HWTEST_F(MultiScreenManagerTest, UniqueSwitch01, TestSize.Level1)
688 {
689 std::vector<ScreenId> screenIds = {};
690 std::vector<DisplayId> displayIds;
691 DMError ret = MultiScreenManager::GetInstance().UniqueSwitch(screenIds, displayIds);
692 EXPECT_EQ(ret, DMError::DM_OK);
693 }
694
695 /**
696 * @tc.name: UniqueSwitch
697 * @tc.desc: screenIds is not empty
698 * @tc.type: FUNC
699 */
700 HWTEST_F(MultiScreenManagerTest, UniqueSwitch02, TestSize.Level1)
701 {
702 std::vector<ScreenId> screenIds = {1001, 1002};
703 std::vector<DisplayId> displayIds;
704 DMError ret = MultiScreenManager::GetInstance().UniqueSwitch(screenIds, displayIds);
705 EXPECT_EQ(ret, DMError::DM_ERROR_INVALID_PARAM);
706 }
707
708 /**
709 * @tc.name: MirrorSwitch
710 * @tc.desc: MirrorSwitch func
711 * @tc.type: FUNC
712 */
713 HWTEST_F(MultiScreenManagerTest, MirrorSwitch, TestSize.Level1)
714 {
715 std::vector<ScreenId> screenIds = {};
716 ScreenId screenGroupId = 0;
717 DMError ret = MultiScreenManager::GetInstance().MirrorSwitch(1, screenIds, DMRect::NONE(), screenGroupId);
718 EXPECT_EQ(ret, DMError::DM_OK);
719 }
720
721
722 /**
723 * @tc.name: MirrorSwitch01
724 * @tc.desc: MirrorSwitch func
725 * @tc.type: FUNC
726 */
727 HWTEST_F(MultiScreenManagerTest, MirrorSwitch01, TestSize.Level1)
728 {
729 std::vector<ScreenId> screenIds = {1001, 1002};
730 ScreenId screenGroupId = 0;
731 DMError ret = MultiScreenManager::GetInstance().MirrorSwitch(1, screenIds, DMRect::NONE(), screenGroupId);
732 EXPECT_EQ(ret, DMError::DM_OK);
733 }
734
735 /**
736 * @tc.name: MirrorSwitch02
737 * @tc.desc: MirrorSwitch func
738 * @tc.type: FUNC
739 */
740 HWTEST_F(MultiScreenManagerTest, MirrorSwitch02, TestSize.Level1)
741 {
742 std::vector<ScreenId> screenIds = {2, 3};
743 ScreenId screenGroupId = 0;
744 DMError ret = MultiScreenManager::GetInstance().MirrorSwitch(1, screenIds, DMRect::NONE(), screenGroupId);
745 EXPECT_EQ(ret, DMError::DM_OK);
746 }
747
748 /**
749 * @tc.name: MirrorSwitch03
750 * @tc.desc: MirrorSwitch func
751 * @tc.type: FUNC
752 */
753 HWTEST_F(MultiScreenManagerTest, MirrorSwitch03, TestSize.Level1)
754 {
755 std::vector<ScreenId> screenIds = {1003, 1002};
756 ScreenId screenGroupId = 0;
757 DMError ret = MultiScreenManager::GetInstance().MirrorSwitch(1, screenIds, DMRect::NONE(), screenGroupId);
758 EXPECT_EQ(ret, DMError::DM_OK);
759 }
760
761 /**
762 * @tc.name: MirrorSwitch04
763 * @tc.desc: MirrorSwitch func
764 * @tc.type: FUNC
765 */
766 HWTEST_F(MultiScreenManagerTest, MirrorSwitch04, TestSize.Level1)
767 {
768 std::vector<ScreenId> screenIds = {1003, 2};
769 ScreenId screenGroupId = 0;
770 DMError ret = MultiScreenManager::GetInstance().MirrorSwitch(1, screenIds, DMRect::NONE(), screenGroupId);
771 EXPECT_EQ(ret, DMError::DM_OK);
772 }
773
774 /**
775 * @tc.name: MirrorSwitch
776 * @tc.desc: MirrorSwitch func
777 * @tc.type: FUNC
778 */
779 HWTEST_F(MultiScreenManagerTest, MirrorSwitch05, TestSize.Level1)
780 {
781 std::vector<ScreenId> screenIds = {};
782 ScreenId screenGroupId = 0;
783 DMRect myRect = {0, 0, 400, 600};
784 DMError ret = MultiScreenManager::GetInstance().MirrorSwitch(1, screenIds, myRect, screenGroupId);
785 EXPECT_EQ(ret, DMError::DM_OK);
786 }
787
788 /**
789 * @tc.name: MultiScreenModeChange
790 * @tc.desc: firstSession == nullptr,secondarySession == nullptr
791 * @tc.type: FUNC
792 */
793 HWTEST_F(MultiScreenManagerTest, MultiScreenModeChange01, TestSize.Level1)
794 {
795 sptr<ScreenSession> firstSession = nullptr;
796 sptr<ScreenSession> secondarySession = nullptr;
797 MultiScreenManager::GetInstance().MultiScreenModeChange(firstSession, secondarySession, "mirror");
798
799 secondarySession = new ScreenSession();
800 MultiScreenManager::GetInstance().MultiScreenModeChange(firstSession, secondarySession, "mirror");
801
802 firstSession = new ScreenSession();
803 MultiScreenManager::GetInstance().MultiScreenModeChange(firstSession, secondarySession, "mirror");
804 EXPECT_NE(secondarySession, nullptr);
805 }
806
807 /**
808 * @tc.name: MultiScreenModeChange
809 * @tc.desc: firstSession == nullptr,secondarySession == nullptr
810 * @tc.type: FUNC
811 */
812 HWTEST_F(MultiScreenManagerTest, MultiScreenModeChange02, TestSize.Level1)
813 {
814 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
815 VirtualScreenOption virtualOption;
816 virtualOption.name_ = "createVirtualOption";
817 auto screenId = ScreenSessionManager::GetInstance().CreateVirtualScreen(
818 virtualOption, displayManagerAgent->AsObject());
819 auto firstSession = ScreenSessionManager::GetInstance().GetScreenSession(screenId);
820
821 sptr<IDisplayManagerAgent> displayManagerAgent1 = new(std::nothrow) DisplayManagerAgentDefault();
822 VirtualScreenOption virtualOption1;
823 virtualOption1.name_ = "createVirtualOption";
824 auto screenId1 = ScreenSessionManager::GetInstance().CreateVirtualScreen(
825 virtualOption1, displayManagerAgent1->AsObject());
826 auto secondarySession = ScreenSessionManager::GetInstance().GetScreenSession(screenId1);
827
828 testClient_ = new ScreenSessionManagerClientTest();
829 ScreenSessionManager::GetInstance().SetClient(testClient_);
830 ASSERT_NE(ScreenSessionManager::GetInstance().GetClientProxy(), nullptr);
831
832 firstSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
833 secondarySession->SetScreenCombination(ScreenCombination::SCREEN_MIRROR);
834 MultiScreenManager::GetInstance().MultiScreenModeChange(firstSession, secondarySession, "extend");
835 ASSERT_EQ(secondarySession->GetScreenCombination(), ScreenCombination::SCREEN_EXTEND);
836
837 ScreenSessionManager::GetInstance().DestroyVirtualScreen(screenId);
838 ScreenSessionManager::GetInstance().DestroyVirtualScreen(screenId1);
839 }
840
841 /**
842 * @tc.name: MultiScreenModeChange
843 * @tc.desc: firstSession == nullptr,secondarySession == nullptr
844 * @tc.type: FUNC
845 */
846 HWTEST_F(MultiScreenManagerTest, MultiScreenModeChange03, TestSize.Level1)
847 {
848 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
849 VirtualScreenOption virtualOption;
850 virtualOption.name_ = "createVirtualOption";
851 auto screenId = ScreenSessionManager::GetInstance().CreateVirtualScreen(
852 virtualOption, displayManagerAgent->AsObject());
853 auto firstSession = ScreenSessionManager::GetInstance().GetScreenSession(screenId);
854
855 sptr<IDisplayManagerAgent> displayManagerAgent1 = new(std::nothrow) DisplayManagerAgentDefault();
856 VirtualScreenOption virtualOption1;
857 virtualOption1.name_ = "createVirtualOption";
858 auto screenId1 = ScreenSessionManager::GetInstance().CreateVirtualScreen(
859 virtualOption1, displayManagerAgent1->AsObject());
860 auto secondarySession = ScreenSessionManager::GetInstance().GetScreenSession(screenId1);
861
862 testClient_ = new ScreenSessionManagerClientTest();
863 ScreenSessionManager::GetInstance().SetClient(testClient_);
864 ASSERT_NE(ScreenSessionManager::GetInstance().GetClientProxy(), nullptr);
865
866 firstSession->SetScreenCombination(ScreenCombination::SCREEN_EXTEND);
867 secondarySession->SetScreenCombination(ScreenCombination::SCREEN_MIRROR);
868 MultiScreenManager::GetInstance().MultiScreenModeChange(firstSession, secondarySession, "mirror");
869 ASSERT_EQ(secondarySession->GetScreenCombination(), ScreenCombination::SCREEN_MIRROR);
870
871 ScreenSessionManager::GetInstance().DestroyVirtualScreen(screenId);
872 ScreenSessionManager::GetInstance().DestroyVirtualScreen(screenId1);
873 }
874
875 /**
876 * @tc.name: DoFirstMainChange
877 * @tc.desc: scbClient null
878 * @tc.type: FUNC
879 */
880 HWTEST_F(MultiScreenManagerTest, DoFirstMainChange01, TestSize.Level1)
881 {
882 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
883 VirtualScreenOption virtualOption;
884 virtualOption.name_ = "createVirtualOption";
885 auto screenId = ScreenSessionManager::GetInstance().CreateVirtualScreen(
886 virtualOption, displayManagerAgent->AsObject());
887 auto firstSession = ScreenSessionManager::GetInstance().GetScreenSession(screenId);
888
889 sptr<IDisplayManagerAgent> displayManagerAgent1 = new(std::nothrow) DisplayManagerAgentDefault();
890 VirtualScreenOption virtualOption1;
891 virtualOption1.name_ = "createVirtualOption";
892 auto screenId1 = ScreenSessionManager::GetInstance().CreateVirtualScreen(
893 virtualOption1, displayManagerAgent1->AsObject());
894 auto secondarySession = ScreenSessionManager::GetInstance().GetScreenSession(screenId1);
895 ScreenCombination secondaryCombination = secondarySession->GetScreenCombination();
896
897 ScreenSessionManager::GetInstance().clientProxy_ = nullptr;
898 MultiScreenManager::GetInstance().DoFirstMainChange(firstSession, secondarySession, "unknown");
899 ASSERT_EQ(secondarySession->GetScreenCombination(), secondaryCombination);
900
901 ScreenSessionManager::GetInstance().DestroyVirtualScreen(screenId);
902 ScreenSessionManager::GetInstance().DestroyVirtualScreen(screenId1);
903 }
904
905 /**
906 * @tc.name: DoFirstMainChange
907 * @tc.desc: param error
908 * @tc.type: FUNC
909 */
910 HWTEST_F(MultiScreenManagerTest, DoFirstMainChange02, TestSize.Level1)
911 {
912 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
913 VirtualScreenOption virtualOption;
914 virtualOption.name_ = "createVirtualOption";
915 auto screenId = ScreenSessionManager::GetInstance().CreateVirtualScreen(
916 virtualOption, displayManagerAgent->AsObject());
917 auto firstSession = ScreenSessionManager::GetInstance().GetScreenSession(screenId);
918
919 sptr<IDisplayManagerAgent> displayManagerAgent1 = new(std::nothrow) DisplayManagerAgentDefault();
920 VirtualScreenOption virtualOption1;
921 virtualOption1.name_ = "createVirtualOption";
922 auto screenId1 = ScreenSessionManager::GetInstance().CreateVirtualScreen(
923 virtualOption1, displayManagerAgent1->AsObject());
924 auto secondarySession = ScreenSessionManager::GetInstance().GetScreenSession(screenId1);
925 ScreenCombination secondaryCombination = secondarySession->GetScreenCombination();
926
927 testClient_ = new ScreenSessionManagerClientTest();
928 ScreenSessionManager::GetInstance().SetClient(testClient_);
929 ASSERT_NE(ScreenSessionManager::GetInstance().GetClientProxy(), nullptr);
930 MultiScreenManager::GetInstance().DoFirstMainChange(firstSession, secondarySession, "unknown");
931 ASSERT_EQ(secondarySession->GetScreenCombination(), secondaryCombination);
932
933 ScreenSessionManager::GetInstance().DestroyVirtualScreen(screenId);
934 ScreenSessionManager::GetInstance().DestroyVirtualScreen(screenId1);
935 }
936
937 /**
938 * @tc.name: DoFirstMainChange
939 * @tc.desc: DoFirstMainChangeExtend
940 * @tc.type: FUNC
941 */
942 HWTEST_F(MultiScreenManagerTest, DoFirstMainChange03, TestSize.Level1)
943 {
944 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
945 VirtualScreenOption virtualOption;
946 virtualOption.name_ = "createVirtualOption";
947 auto screenId = ScreenSessionManager::GetInstance().CreateVirtualScreen(
948 virtualOption, displayManagerAgent->AsObject());
949 auto firstSession = ScreenSessionManager::GetInstance().GetScreenSession(screenId);
950
951 sptr<IDisplayManagerAgent> displayManagerAgent1 = new(std::nothrow) DisplayManagerAgentDefault();
952 VirtualScreenOption virtualOption1;
953 virtualOption1.name_ = "createVirtualOption";
954 auto screenId1 = ScreenSessionManager::GetInstance().CreateVirtualScreen(
955 virtualOption1, displayManagerAgent1->AsObject());
956 auto secondarySession = ScreenSessionManager::GetInstance().GetScreenSession(screenId1);
957 secondarySession->SetScreenCombination(ScreenCombination::SCREEN_MIRROR);
958
959 ASSERT_NE(ScreenSessionManager::GetInstance().GetClientProxy(), nullptr);
960 MultiScreenManager::GetInstance().DoFirstMainChange(firstSession, secondarySession, "extend");
961 ASSERT_EQ(secondarySession->GetScreenCombination(), ScreenCombination::SCREEN_EXTEND);
962
963 ScreenSessionManager::GetInstance().DestroyVirtualScreen(screenId);
964 ScreenSessionManager::GetInstance().DestroyVirtualScreen(screenId1);
965 }
966
967 /**
968 * @tc.name: DoFirstMainChange
969 * @tc.desc: main change extend, no need to change
970 * @tc.type: FUNC
971 */
972 HWTEST_F(MultiScreenManagerTest, DoFirstMainChange04, TestSize.Level1)
973 {
974 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
975 VirtualScreenOption virtualOption;
976 virtualOption.name_ = "createVirtualOption";
977 auto screenId = ScreenSessionManager::GetInstance().CreateVirtualScreen(
978 virtualOption, displayManagerAgent->AsObject());
979 auto firstSession = ScreenSessionManager::GetInstance().GetScreenSession(screenId);
980
981 sptr<IDisplayManagerAgent> displayManagerAgent1 = new(std::nothrow) DisplayManagerAgentDefault();
982 VirtualScreenOption virtualOption1;
983 virtualOption1.name_ = "createVirtualOption";
984 auto screenId1 = ScreenSessionManager::GetInstance().CreateVirtualScreen(
985 virtualOption1, displayManagerAgent1->AsObject());
986 auto secondarySession = ScreenSessionManager::GetInstance().GetScreenSession(screenId1);
987 secondarySession->SetScreenCombination(ScreenCombination::SCREEN_ALONE);
988
989 ASSERT_NE(ScreenSessionManager::GetInstance().GetClientProxy(), nullptr);
990 MultiScreenManager::GetInstance().DoFirstMainChange(firstSession, secondarySession, "extend");
991 ASSERT_NE(secondarySession->GetScreenCombination(), ScreenCombination::SCREEN_EXTEND);
992
993 ScreenSessionManager::GetInstance().DestroyVirtualScreen(screenId);
994 ScreenSessionManager::GetInstance().DestroyVirtualScreen(screenId1);
995 }
996
997 /**
998 * @tc.name: DoFirstMainChange
999 * @tc.desc: DoFirstMainChangeMirror
1000 * @tc.type: FUNC
1001 */
1002 HWTEST_F(MultiScreenManagerTest, DoFirstMainChange05, TestSize.Level1)
1003 {
1004 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
1005 VirtualScreenOption virtualOption;
1006 virtualOption.name_ = "createVirtualOption";
1007 auto screenId = ScreenSessionManager::GetInstance().CreateVirtualScreen(
1008 virtualOption, displayManagerAgent->AsObject());
1009 auto firstSession = ScreenSessionManager::GetInstance().GetScreenSession(screenId);
1010
1011 sptr<IDisplayManagerAgent> displayManagerAgent1 = new(std::nothrow) DisplayManagerAgentDefault();
1012 VirtualScreenOption virtualOption1;
1013 virtualOption1.name_ = "createVirtualOption";
1014 auto screenId1 = ScreenSessionManager::GetInstance().CreateVirtualScreen(
1015 virtualOption1, displayManagerAgent1->AsObject());
1016 auto secondarySession = ScreenSessionManager::GetInstance().GetScreenSession(screenId1);
1017 secondarySession->SetScreenCombination(ScreenCombination::SCREEN_EXTEND);
1018
1019 ASSERT_NE(ScreenSessionManager::GetInstance().GetClientProxy(), nullptr);
1020 MultiScreenManager::GetInstance().DoFirstMainChange(firstSession, secondarySession, "mirror");
1021 ASSERT_EQ(secondarySession->GetScreenCombination(), ScreenCombination::SCREEN_MIRROR);
1022
1023 ScreenSessionManager::GetInstance().DestroyVirtualScreen(screenId);
1024 ScreenSessionManager::GetInstance().DestroyVirtualScreen(screenId1);
1025 }
1026
1027 /**
1028 * @tc.name: DoFirstMainChange
1029 * @tc.desc: main change mirror, no need to change
1030 * @tc.type: FUNC
1031 */
1032 HWTEST_F(MultiScreenManagerTest, DoFirstMainChange06, TestSize.Level1)
1033 {
1034 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
1035 VirtualScreenOption virtualOption;
1036 virtualOption.name_ = "createVirtualOption";
1037 auto screenId = ScreenSessionManager::GetInstance().CreateVirtualScreen(
1038 virtualOption, displayManagerAgent->AsObject());
1039 auto firstSession = ScreenSessionManager::GetInstance().GetScreenSession(screenId);
1040
1041 sptr<IDisplayManagerAgent> displayManagerAgent1 = new(std::nothrow) DisplayManagerAgentDefault();
1042 VirtualScreenOption virtualOption1;
1043 virtualOption1.name_ = "createVirtualOption";
1044 auto screenId1 = ScreenSessionManager::GetInstance().CreateVirtualScreen(
1045 virtualOption1, displayManagerAgent1->AsObject());
1046 auto secondarySession = ScreenSessionManager::GetInstance().GetScreenSession(screenId1);
1047 secondarySession->SetScreenCombination(ScreenCombination::SCREEN_ALONE);
1048
1049 ASSERT_NE(ScreenSessionManager::GetInstance().GetClientProxy(), nullptr);
1050 MultiScreenManager::GetInstance().DoFirstMainChange(firstSession, secondarySession, "mirror");
1051 ASSERT_NE(secondarySession->GetScreenCombination(), ScreenCombination::SCREEN_MIRROR);
1052
1053 ScreenSessionManager::GetInstance().DestroyVirtualScreen(screenId);
1054 ScreenSessionManager::GetInstance().DestroyVirtualScreen(screenId1);
1055 }
1056
1057 /**
1058 * @tc.name: DoFirstMirrorChange
1059 * @tc.desc: scbClient null
1060 * @tc.type: FUNC
1061 */
1062 HWTEST_F(MultiScreenManagerTest, DoFirstMirrorChange01, TestSize.Level1)
1063 {
1064 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
1065 VirtualScreenOption virtualOption;
1066 virtualOption.name_ = "createVirtualOption";
1067 auto screenId = ScreenSessionManager::GetInstance().CreateVirtualScreen(
1068 virtualOption, displayManagerAgent->AsObject());
1069 auto firstSession = ScreenSessionManager::GetInstance().GetScreenSession(screenId);
1070
1071 sptr<IDisplayManagerAgent> displayManagerAgent1 = new(std::nothrow) DisplayManagerAgentDefault();
1072 VirtualScreenOption virtualOption1;
1073 virtualOption1.name_ = "createVirtualOption";
1074 auto screenId1 = ScreenSessionManager::GetInstance().CreateVirtualScreen(
1075 virtualOption1, displayManagerAgent1->AsObject());
1076 auto secondarySession = ScreenSessionManager::GetInstance().GetScreenSession(screenId1);
1077 ScreenCombination secondaryCombination = secondarySession->GetScreenCombination();
1078
1079 ScreenSessionManager::GetInstance().clientProxy_ = nullptr;
1080 MultiScreenManager::GetInstance().DoFirstMirrorChange(firstSession, secondarySession, "unknown");
1081 ASSERT_EQ(secondarySession->GetScreenCombination(), secondaryCombination);
1082
1083 ScreenSessionManager::GetInstance().DestroyVirtualScreen(screenId);
1084 ScreenSessionManager::GetInstance().DestroyVirtualScreen(screenId1);
1085 }
1086
1087 /**
1088 * @tc.name: DoFirstMirrorChange
1089 * @tc.desc: param error
1090 * @tc.type: FUNC
1091 */
1092 HWTEST_F(MultiScreenManagerTest, DoFirstMirrorChange02, TestSize.Level1)
1093 {
1094 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
1095 VirtualScreenOption virtualOption;
1096 virtualOption.name_ = "createVirtualOption";
1097 auto screenId = ScreenSessionManager::GetInstance().CreateVirtualScreen(
1098 virtualOption, displayManagerAgent->AsObject());
1099 auto firstSession = ScreenSessionManager::GetInstance().GetScreenSession(screenId);
1100
1101 sptr<IDisplayManagerAgent> displayManagerAgent1 = new(std::nothrow) DisplayManagerAgentDefault();
1102 VirtualScreenOption virtualOption1;
1103 virtualOption1.name_ = "createVirtualOption";
1104 auto screenId1 = ScreenSessionManager::GetInstance().CreateVirtualScreen(
1105 virtualOption1, displayManagerAgent1->AsObject());
1106 auto secondarySession = ScreenSessionManager::GetInstance().GetScreenSession(screenId1);
1107 ScreenCombination secondaryCombination = secondarySession->GetScreenCombination();
1108
1109 testClient_ = new ScreenSessionManagerClientTest();
1110 ScreenSessionManager::GetInstance().SetClient(testClient_);
1111 ASSERT_NE(ScreenSessionManager::GetInstance().GetClientProxy(), nullptr);
1112 MultiScreenManager::GetInstance().DoFirstMirrorChange(firstSession, secondarySession, "unknown");
1113 ASSERT_EQ(secondarySession->GetScreenCombination(), secondaryCombination);
1114
1115 ScreenSessionManager::GetInstance().DestroyVirtualScreen(screenId);
1116 ScreenSessionManager::GetInstance().DestroyVirtualScreen(screenId1);
1117 }
1118
1119 /**
1120 * @tc.name: DoFirstMirrorChange
1121 * @tc.desc: DoFirstMirrorChangeExtend
1122 * @tc.type: FUNC
1123 */
1124 HWTEST_F(MultiScreenManagerTest, DoFirstMirrorChange03, TestSize.Level1)
1125 {
1126 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
1127 VirtualScreenOption virtualOption;
1128 virtualOption.name_ = "createVirtualOption";
1129 auto screenId = ScreenSessionManager::GetInstance().CreateVirtualScreen(
1130 virtualOption, displayManagerAgent->AsObject());
1131 auto firstSession = ScreenSessionManager::GetInstance().GetScreenSession(screenId);
1132
1133 sptr<IDisplayManagerAgent> displayManagerAgent1 = new(std::nothrow) DisplayManagerAgentDefault();
1134 VirtualScreenOption virtualOption1;
1135 virtualOption1.name_ = "createVirtualOption";
1136 auto screenId1 = ScreenSessionManager::GetInstance().CreateVirtualScreen(
1137 virtualOption1, displayManagerAgent1->AsObject());
1138 auto secondarySession = ScreenSessionManager::GetInstance().GetScreenSession(screenId1);
1139
1140 ASSERT_NE(ScreenSessionManager::GetInstance().GetClientProxy(), nullptr);
1141 MultiScreenManager::GetInstance().DoFirstMirrorChange(firstSession, secondarySession, "extend");
1142 ASSERT_EQ(secondarySession->GetScreenCombination(), ScreenCombination::SCREEN_EXTEND);
1143
1144 ScreenSessionManager::GetInstance().DestroyVirtualScreen(screenId);
1145 ScreenSessionManager::GetInstance().DestroyVirtualScreen(screenId1);
1146 }
1147
1148 /**
1149 * @tc.name: DoFirstMirrorChange
1150 * @tc.desc: DoFirstMirrorChangeMirror
1151 * @tc.type: FUNC
1152 */
1153 HWTEST_F(MultiScreenManagerTest, DoFirstMirrorChange04, TestSize.Level1)
1154 {
1155 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
1156 VirtualScreenOption virtualOption;
1157 virtualOption.name_ = "createVirtualOption";
1158 auto screenId = ScreenSessionManager::GetInstance().CreateVirtualScreen(
1159 virtualOption, displayManagerAgent->AsObject());
1160 auto firstSession = ScreenSessionManager::GetInstance().GetScreenSession(screenId);
1161
1162 sptr<IDisplayManagerAgent> displayManagerAgent1 = new(std::nothrow) DisplayManagerAgentDefault();
1163 VirtualScreenOption virtualOption1;
1164 virtualOption1.name_ = "createVirtualOption";
1165 auto screenId1 = ScreenSessionManager::GetInstance().CreateVirtualScreen(
1166 virtualOption1, displayManagerAgent1->AsObject());
1167 auto secondarySession = ScreenSessionManager::GetInstance().GetScreenSession(screenId1);
1168
1169 ASSERT_NE(ScreenSessionManager::GetInstance().GetClientProxy(), nullptr);
1170 MultiScreenManager::GetInstance().DoFirstMirrorChange(firstSession, secondarySession, "mirror");
1171 ASSERT_EQ(secondarySession->GetScreenCombination(), ScreenCombination::SCREEN_MIRROR);
1172
1173 ScreenSessionManager::GetInstance().DestroyVirtualScreen(screenId);
1174 ScreenSessionManager::GetInstance().DestroyVirtualScreen(screenId1);
1175 }
1176
1177 /**
1178 * @tc.name: DoFirstExtendChange
1179 * @tc.desc: param error
1180 * @tc.type: FUNC
1181 */
1182 HWTEST_F(MultiScreenManagerTest, DoFirstExtendChange01, TestSize.Level1)
1183 {
1184 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
1185 VirtualScreenOption virtualOption;
1186 virtualOption.name_ = "createVirtualOption";
1187 auto screenId = ScreenSessionManager::GetInstance().CreateVirtualScreen(
1188 virtualOption, displayManagerAgent->AsObject());
1189 auto firstSession = ScreenSessionManager::GetInstance().GetScreenSession(screenId);
1190
1191 sptr<IDisplayManagerAgent> displayManagerAgent1 = new(std::nothrow) DisplayManagerAgentDefault();
1192 VirtualScreenOption virtualOption1;
1193 virtualOption1.name_ = "createVirtualOption";
1194 auto screenId1 = ScreenSessionManager::GetInstance().CreateVirtualScreen(
1195 virtualOption1, displayManagerAgent1->AsObject());
1196 auto secondarySession = ScreenSessionManager::GetInstance().GetScreenSession(screenId1);
1197 ScreenCombination secondaryCombination = secondarySession->GetScreenCombination();
1198
1199 MultiScreenManager::GetInstance().DoFirstExtendChange(firstSession, secondarySession, "unknown");
1200 ASSERT_EQ(secondarySession->GetScreenCombination(), secondaryCombination);
1201
1202 ScreenSessionManager::GetInstance().DestroyVirtualScreen(screenId);
1203 ScreenSessionManager::GetInstance().DestroyVirtualScreen(screenId1);
1204 }
1205
1206 /**
1207 * @tc.name: DoFirstExtendChange
1208 * @tc.desc: extend change extend
1209 * @tc.type: FUNC
1210 */
1211 HWTEST_F(MultiScreenManagerTest, DoFirstExtendChange02, TestSize.Level1)
1212 {
1213 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
1214 VirtualScreenOption virtualOption;
1215 virtualOption.name_ = "createVirtualOption";
1216 auto screenId = ScreenSessionManager::GetInstance().CreateVirtualScreen(
1217 virtualOption, displayManagerAgent->AsObject());
1218 auto firstSession = ScreenSessionManager::GetInstance().GetScreenSession(screenId);
1219
1220 sptr<IDisplayManagerAgent> displayManagerAgent1 = new(std::nothrow) DisplayManagerAgentDefault();
1221 VirtualScreenOption virtualOption1;
1222 virtualOption1.name_ = "createVirtualOption";
1223 auto screenId1 = ScreenSessionManager::GetInstance().CreateVirtualScreen(
1224 virtualOption1, displayManagerAgent1->AsObject());
1225 auto secondarySession = ScreenSessionManager::GetInstance().GetScreenSession(screenId1);
1226
1227 MultiScreenManager::GetInstance().DoFirstExtendChange(firstSession, secondarySession, "extend");
1228 ASSERT_EQ(secondarySession->GetScreenCombination(), ScreenCombination::SCREEN_EXTEND);
1229
1230 ScreenSessionManager::GetInstance().DestroyVirtualScreen(screenId);
1231 ScreenSessionManager::GetInstance().DestroyVirtualScreen(screenId1);
1232 }
1233
1234 /**
1235 * @tc.name: DoFirstExtendChange
1236 * @tc.desc: extend change mirror
1237 * @tc.type: FUNC
1238 */
1239 HWTEST_F(MultiScreenManagerTest, DoFirstExtendChange03, TestSize.Level1)
1240 {
1241 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
1242 VirtualScreenOption virtualOption;
1243 virtualOption.name_ = "createVirtualOption";
1244 auto screenId = ScreenSessionManager::GetInstance().CreateVirtualScreen(
1245 virtualOption, displayManagerAgent->AsObject());
1246 auto firstSession = ScreenSessionManager::GetInstance().GetScreenSession(screenId);
1247
1248 sptr<IDisplayManagerAgent> displayManagerAgent1 = new(std::nothrow) DisplayManagerAgentDefault();
1249 VirtualScreenOption virtualOption1;
1250 virtualOption1.name_ = "createVirtualOption";
1251 auto screenId1 = ScreenSessionManager::GetInstance().CreateVirtualScreen(
1252 virtualOption1, displayManagerAgent1->AsObject());
1253 auto secondarySession = ScreenSessionManager::GetInstance().GetScreenSession(screenId1);
1254
1255 MultiScreenManager::GetInstance().DoFirstExtendChange(firstSession, secondarySession, "mirror");
1256 ASSERT_EQ(secondarySession->GetScreenCombination(), ScreenCombination::SCREEN_MIRROR);
1257
1258 ScreenSessionManager::GetInstance().DestroyVirtualScreen(screenId);
1259 ScreenSessionManager::GetInstance().DestroyVirtualScreen(screenId1);
1260 }
1261
1262 /**
1263 * @tc.name: SetLastScreenMode
1264 * @tc.desc: SetLastScreenMode func
1265 * @tc.type: FUNC
1266 */
1267 HWTEST_F(MultiScreenManagerTest, SetLastScreenMode, TestSize.Level1)
1268 {
1269 ScreenId mainScreenId = 0;
1270 MultiScreenMode secondaryScreenMode = MultiScreenMode::SCREEN_MIRROR;
1271 MultiScreenManager::GetInstance().SetLastScreenMode(mainScreenId, secondaryScreenMode);
1272 ScreenId realId = MultiScreenManager::GetInstance().lastScreenMode_.first;
1273 MultiScreenMode realScreenMode = MultiScreenManager::GetInstance().lastScreenMode_.second;
1274 EXPECT_EQ(realId, mainScreenId);
1275 EXPECT_EQ(realScreenMode, secondaryScreenMode);
1276 }
1277
1278 /**
1279 * @tc.name: InternalScreenOnChange01
1280 * @tc.desc: external mirror to internal mirror
1281 * @tc.type: FUNC
1282 */
1283 HWTEST_F(MultiScreenManagerTest, InternalScreenOnChange01, TestSize.Level1)
1284 {
1285 ScreenId internalId = 0;
1286 ScreenSessionConfig internalConfig = {
1287 .screenId = internalId,
1288 };
1289 sptr<ScreenSession> internalSession = new ScreenSession(internalConfig,
1290 ScreenSessionReason::CREATE_SESSION_FOR_REAL);
1291 internalSession->SetIsInternal(true);
1292 internalSession->SetIsExtend(true);
1293 internalSession->SetScreenCombination(ScreenCombination::SCREEN_MIRROR);
1294 {
1295 std::lock_guard<std::recursive_mutex>
1296 lock(ScreenSessionManager::GetInstance().screenSessionMapMutex_);
1297 ScreenSessionManager::GetInstance().screenSessionMap_[internalId] = internalSession;
1298 }
1299
1300 ScreenId externalId = 11;
1301 ScreenSessionConfig externalConfig = {
1302 .screenId = externalId,
1303 };
1304 sptr<ScreenSession> externalSession = new ScreenSession(externalConfig,
1305 ScreenSessionReason::CREATE_SESSION_FOR_MIRROR);
1306 externalSession->SetIsInternal(false);
1307 externalSession->SetIsExtend(false);
1308 externalSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
1309 {
1310 std::lock_guard<std::recursive_mutex>
1311 lock(ScreenSessionManager::GetInstance().screenSessionMapMutex_);
1312 ScreenSessionManager::GetInstance().screenSessionMap_[externalId] = externalSession;
1313 }
1314
1315 ScreenId mainScreenId = internalId;
1316 MultiScreenMode secondaryScreenMode = MultiScreenMode::SCREEN_MIRROR;
1317 MultiScreenManager::GetInstance().SetLastScreenMode(mainScreenId, secondaryScreenMode);
1318 MultiScreenManager::GetInstance().InternalScreenOnChange(internalSession, externalSession);
1319
1320 EXPECT_EQ(false, internalSession->GetIsExtend());
1321 EXPECT_EQ(true, externalSession->GetIsExtend());
1322 EXPECT_EQ(ScreenCombination::SCREEN_MAIN, internalSession->GetScreenCombination());
1323 EXPECT_EQ(ScreenCombination::SCREEN_MIRROR, externalSession->GetScreenCombination());
1324 {
1325 std::lock_guard<std::recursive_mutex>
1326 lock(ScreenSessionManager::GetInstance().screenSessionMapMutex_);
1327 ScreenSessionManager::GetInstance().screenSessionMap_.erase(internalId);
1328 ScreenSessionManager::GetInstance().screenSessionMap_.erase(externalId);
1329 }
1330 }
1331
1332 /**
1333 * @tc.name: InternalScreenOnChange02
1334 * @tc.desc: no need to change or paramater error
1335 * @tc.type: FUNC
1336 */
1337 HWTEST_F(MultiScreenManagerTest, InternalScreenOnChange02, TestSize.Level1)
1338 {
1339 ScreenId internalId = 0;
1340 ScreenSessionConfig internalConfig = {
1341 .screenId = internalId,
1342 };
1343 sptr<ScreenSession> internalSession = new ScreenSession(internalConfig,
1344 ScreenSessionReason::CREATE_SESSION_FOR_REAL);
1345 internalSession->SetIsInternal(true);
1346 internalSession->SetIsExtend(true);
1347 internalSession->SetScreenCombination(ScreenCombination::SCREEN_MIRROR);
1348 {
1349 std::lock_guard<std::recursive_mutex>
1350 lock(ScreenSessionManager::GetInstance().screenSessionMapMutex_);
1351 ScreenSessionManager::GetInstance().screenSessionMap_[internalId] = internalSession;
1352 }
1353
1354 ScreenId externalId = 11;
1355 ScreenSessionConfig externalConfig = {
1356 .screenId = externalId,
1357 };
1358 sptr<ScreenSession> externalSession = new ScreenSession(externalConfig,
1359 ScreenSessionReason::CREATE_SESSION_FOR_MIRROR);
1360 externalSession->SetIsInternal(false);
1361 externalSession->SetIsExtend(false);
1362 externalSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
1363 {
1364 std::lock_guard<std::recursive_mutex>
1365 lock(ScreenSessionManager::GetInstance().screenSessionMapMutex_);
1366 ScreenSessionManager::GetInstance().screenSessionMap_[externalId] = externalSession;
1367 }
1368
1369 ScreenId mainScreenId = externalId;
1370 MultiScreenMode secondaryScreenMode = MultiScreenMode::SCREEN_MIRROR;
1371 MultiScreenManager::GetInstance().SetLastScreenMode(mainScreenId, secondaryScreenMode);
1372 MultiScreenManager::GetInstance().InternalScreenOnChange(internalSession, externalSession);
1373
1374 EXPECT_EQ(true, internalSession->GetIsExtend());
1375 EXPECT_EQ(false, externalSession->GetIsExtend());
1376 EXPECT_EQ(ScreenCombination::SCREEN_MIRROR, internalSession->GetScreenCombination());
1377 EXPECT_EQ(ScreenCombination::SCREEN_MAIN, externalSession->GetScreenCombination());
1378 {
1379 std::lock_guard<std::recursive_mutex>
1380 lock(ScreenSessionManager::GetInstance().screenSessionMapMutex_);
1381 ScreenSessionManager::GetInstance().screenSessionMap_.erase(internalId);
1382 ScreenSessionManager::GetInstance().screenSessionMap_.erase(externalId);
1383 }
1384 }
1385
1386 /**
1387 * @tc.name: InternalScreenOnChange03
1388 * @tc.desc: external mirror to internal extend
1389 * @tc.type: FUNC
1390 */
1391 HWTEST_F(MultiScreenManagerTest, InternalScreenOnChange03, TestSize.Level1)
1392 {
1393 ScreenId internalId = 0;
1394 ScreenSessionConfig internalConfig = {
1395 .screenId = internalId,
1396 };
1397 sptr<ScreenSession> internalSession = new ScreenSession(internalConfig,
1398 ScreenSessionReason::CREATE_SESSION_FOR_REAL);
1399 internalSession->SetIsInternal(true);
1400 internalSession->SetIsExtend(true);
1401 internalSession->SetScreenCombination(ScreenCombination::SCREEN_MIRROR);
1402 {
1403 std::lock_guard<std::recursive_mutex>
1404 lock(ScreenSessionManager::GetInstance().screenSessionMapMutex_);
1405 ScreenSessionManager::GetInstance().screenSessionMap_[internalId] = internalSession;
1406 }
1407
1408 ScreenId externalId = 11;
1409 ScreenSessionConfig externalConfig = {
1410 .screenId = externalId,
1411 };
1412 sptr<ScreenSession> externalSession = new ScreenSession(externalConfig,
1413 ScreenSessionReason::CREATE_SESSION_FOR_MIRROR);
1414 externalSession->SetIsInternal(false);
1415 externalSession->SetIsExtend(false);
1416 externalSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
1417 {
1418 std::lock_guard<std::recursive_mutex>
1419 lock(ScreenSessionManager::GetInstance().screenSessionMapMutex_);
1420 ScreenSessionManager::GetInstance().screenSessionMap_[externalId] = externalSession;
1421 }
1422
1423 ScreenId mainScreenId = internalId;
1424 MultiScreenMode secondaryScreenMode = MultiScreenMode::SCREEN_EXTEND;
1425 MultiScreenManager::GetInstance().SetLastScreenMode(mainScreenId, secondaryScreenMode);
1426 MultiScreenManager::GetInstance().InternalScreenOnChange(internalSession, externalSession);
1427
1428 EXPECT_EQ(false, internalSession->GetIsExtend());
1429 EXPECT_EQ(true, externalSession->GetIsExtend());
1430 EXPECT_EQ(ScreenCombination::SCREEN_MAIN, internalSession->GetScreenCombination());
1431 EXPECT_EQ(ScreenCombination::SCREEN_EXTEND, externalSession->GetScreenCombination());
1432 {
1433 std::lock_guard<std::recursive_mutex>
1434 lock(ScreenSessionManager::GetInstance().screenSessionMapMutex_);
1435 ScreenSessionManager::GetInstance().screenSessionMap_.erase(internalId);
1436 ScreenSessionManager::GetInstance().screenSessionMap_.erase(externalId);
1437 }
1438 }
1439
1440 /**
1441 * @tc.name: InternalScreenOnChange04
1442 * @tc.desc: external mirror to external extend
1443 * @tc.type: FUNC
1444 */
1445 HWTEST_F(MultiScreenManagerTest, InternalScreenOnChange04, TestSize.Level1)
1446 {
1447 ScreenId internalId = 0;
1448 ScreenSessionConfig internalConfig = {
1449 .screenId = internalId,
1450 };
1451 sptr<ScreenSession> internalSession = new ScreenSession(internalConfig,
1452 ScreenSessionReason::CREATE_SESSION_FOR_REAL);
1453 internalSession->SetIsInternal(true);
1454 internalSession->SetIsExtend(true);
1455 internalSession->SetScreenCombination(ScreenCombination::SCREEN_MIRROR);
1456 {
1457 std::lock_guard<std::recursive_mutex>
1458 lock(ScreenSessionManager::GetInstance().screenSessionMapMutex_);
1459 ScreenSessionManager::GetInstance().screenSessionMap_[internalId] = internalSession;
1460 }
1461
1462 ScreenId externalId = 11;
1463 ScreenSessionConfig externalConfig = {
1464 .screenId = externalId,
1465 };
1466 sptr<ScreenSession> externalSession = new ScreenSession(externalConfig,
1467 ScreenSessionReason::CREATE_SESSION_FOR_MIRROR);
1468 externalSession->SetIsInternal(false);
1469 externalSession->SetIsExtend(false);
1470 externalSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
1471 {
1472 std::lock_guard<std::recursive_mutex>
1473 lock(ScreenSessionManager::GetInstance().screenSessionMapMutex_);
1474 ScreenSessionManager::GetInstance().screenSessionMap_[externalId] = externalSession;
1475 }
1476
1477 ScreenId mainScreenId = externalId;
1478 MultiScreenMode secondaryScreenMode = MultiScreenMode::SCREEN_EXTEND;
1479 MultiScreenManager::GetInstance().SetLastScreenMode(mainScreenId, secondaryScreenMode);
1480 MultiScreenManager::GetInstance().InternalScreenOnChange(internalSession, externalSession);
1481
1482 EXPECT_EQ(true, internalSession->GetIsExtend());
1483 EXPECT_EQ(false, externalSession->GetIsExtend());
1484 EXPECT_EQ(ScreenCombination::SCREEN_EXTEND, internalSession->GetScreenCombination());
1485 EXPECT_EQ(ScreenCombination::SCREEN_MAIN, externalSession->GetScreenCombination());
1486 {
1487 std::lock_guard<std::recursive_mutex>
1488 lock(ScreenSessionManager::GetInstance().screenSessionMapMutex_);
1489 ScreenSessionManager::GetInstance().screenSessionMap_.erase(internalId);
1490 ScreenSessionManager::GetInstance().screenSessionMap_.erase(externalId);
1491 }
1492 }
1493
1494 /**
1495 * @tc.name: InternalScreenOnChange05
1496 * @tc.desc: mode not restored
1497 * @tc.type: FUNC
1498 */
1499 HWTEST_F(MultiScreenManagerTest, InternalScreenOnChange05, TestSize.Level1)
1500 {
1501 ScreenId internalId = 0;
1502 ScreenSessionConfig internalConfig = {
1503 .screenId = internalId,
1504 };
1505 sptr<ScreenSession> internalSession = new ScreenSession(internalConfig,
1506 ScreenSessionReason::CREATE_SESSION_FOR_REAL);
1507 internalSession->SetIsInternal(true);
1508 internalSession->SetIsExtend(true);
1509 internalSession->SetScreenCombination(ScreenCombination::SCREEN_MIRROR);
1510 {
1511 std::lock_guard<std::recursive_mutex>
1512 lock(ScreenSessionManager::GetInstance().screenSessionMapMutex_);
1513 ScreenSessionManager::GetInstance().screenSessionMap_[internalId] = internalSession;
1514 }
1515
1516 ScreenId externalId = 11;
1517 ScreenSessionConfig externalConfig = {
1518 .screenId = externalId,
1519 };
1520 sptr<ScreenSession> externalSession = new ScreenSession(externalConfig,
1521 ScreenSessionReason::CREATE_SESSION_FOR_MIRROR);
1522 externalSession->SetIsInternal(false);
1523 externalSession->SetIsExtend(false);
1524 externalSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
1525 {
1526 std::lock_guard<std::recursive_mutex>
1527 lock(ScreenSessionManager::GetInstance().screenSessionMapMutex_);
1528 ScreenSessionManager::GetInstance().screenSessionMap_[externalId] = externalSession;
1529 }
1530
1531 ScreenId mainScreenId = SCREEN_ID_INVALID;
1532 MultiScreenMode secondaryScreenMode = MultiScreenMode::SCREEN_MIRROR;
1533 MultiScreenManager::GetInstance().SetLastScreenMode(mainScreenId, secondaryScreenMode);
1534 MultiScreenManager::GetInstance().InternalScreenOnChange(internalSession, externalSession);
1535
1536 ScreenId realId = MultiScreenManager::GetInstance().lastScreenMode_.first;
1537 MultiScreenMode realScreenMode = MultiScreenManager::GetInstance().lastScreenMode_.second;
1538 EXPECT_EQ(realId, mainScreenId);
1539 EXPECT_EQ(realScreenMode, secondaryScreenMode);
1540 EXPECT_EQ(true, internalSession->GetIsExtend());
1541 EXPECT_EQ(false, externalSession->GetIsExtend());
1542 {
1543 std::lock_guard<std::recursive_mutex>
1544 lock(ScreenSessionManager::GetInstance().screenSessionMapMutex_);
1545 ScreenSessionManager::GetInstance().screenSessionMap_.erase(internalId);
1546 ScreenSessionManager::GetInstance().screenSessionMap_.erase(externalId);
1547 }
1548 }
1549
1550 /**
1551 * @tc.name: InternalScreenOnChange06
1552 * @tc.desc: session nullptr
1553 * @tc.type: FUNC
1554 */
1555 HWTEST_F(MultiScreenManagerTest, InternalScreenOnChange06, TestSize.Level1)
1556 {
1557 ScreenId internalId = 0;
1558 ScreenSessionConfig internalConfig = {
1559 .screenId = internalId,
1560 };
1561 sptr<ScreenSession> internalSession = new ScreenSession(internalConfig,
1562 ScreenSessionReason::CREATE_SESSION_FOR_REAL);
1563 internalSession->SetIsInternal(true);
1564 internalSession->SetIsExtend(false);
1565 internalSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
1566 {
1567 std::lock_guard<std::recursive_mutex>
1568 lock(ScreenSessionManager::GetInstance().screenSessionMapMutex_);
1569 ScreenSessionManager::GetInstance().screenSessionMap_[internalId] = internalSession;
1570 }
1571
1572 sptr<ScreenSession> externalSession = nullptr;
1573
1574 ScreenId mainScreenId = internalId;
1575 MultiScreenMode secondaryScreenMode = MultiScreenMode::SCREEN_MIRROR;
1576 MultiScreenManager::GetInstance().SetLastScreenMode(mainScreenId, secondaryScreenMode);
1577 MultiScreenManager::GetInstance().InternalScreenOnChange(internalSession, externalSession);
1578
1579 EXPECT_EQ(false, internalSession->GetIsExtend());
1580 EXPECT_EQ(ScreenCombination::SCREEN_MAIN, internalSession->GetScreenCombination());
1581 {
1582 std::lock_guard<std::recursive_mutex>
1583 lock(ScreenSessionManager::GetInstance().screenSessionMapMutex_);
1584 ScreenSessionManager::GetInstance().screenSessionMap_.erase(internalId);
1585 }
1586 }
1587
1588 /**
1589 * @tc.name: InternalScreenOffChange01
1590 * @tc.desc: internal mirror to external mirror
1591 * @tc.type: FUNC
1592 */
1593 HWTEST_F(MultiScreenManagerTest, InternalScreenOffChange01, TestSize.Level1)
1594 {
1595 ScreenId internalId = 0;
1596 ScreenSessionConfig internalConfig = {
1597 .screenId = internalId,
1598 };
1599 sptr<ScreenSession> internalSession = new ScreenSession(internalConfig,
1600 ScreenSessionReason::CREATE_SESSION_FOR_REAL);
1601 internalSession->SetIsInternal(true);
1602 internalSession->SetIsExtend(false);
1603 internalSession->SetIsCurrentInUse(true);
1604 internalSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
1605 {
1606 std::lock_guard<std::recursive_mutex>
1607 lock(ScreenSessionManager::GetInstance().screenSessionMapMutex_);
1608 ScreenSessionManager::GetInstance().screenSessionMap_[internalId] = internalSession;
1609 }
1610
1611 ScreenId externalId = 11;
1612 ScreenSessionConfig externalConfig = {
1613 .screenId = externalId,
1614 };
1615 sptr<ScreenSession> externalSession = new ScreenSession(externalConfig,
1616 ScreenSessionReason::CREATE_SESSION_FOR_MIRROR);
1617 externalSession->SetIsInternal(false);
1618 externalSession->SetIsExtend(true);
1619 externalSession->SetIsCurrentInUse(true);
1620 externalSession->SetScreenCombination(ScreenCombination::SCREEN_MIRROR);
1621 {
1622 std::lock_guard<std::recursive_mutex>
1623 lock(ScreenSessionManager::GetInstance().screenSessionMapMutex_);
1624 ScreenSessionManager::GetInstance().screenSessionMap_[externalId] = externalSession;
1625 }
1626
1627 MultiScreenManager::GetInstance().InternalScreenOffChange(internalSession, externalSession);
1628
1629 EXPECT_EQ(true, internalSession->GetIsExtend());
1630 EXPECT_EQ(false, externalSession->GetIsExtend());
1631 EXPECT_EQ(ScreenCombination::SCREEN_MIRROR, internalSession->GetScreenCombination());
1632 EXPECT_EQ(ScreenCombination::SCREEN_MAIN, externalSession->GetScreenCombination());
1633 {
1634 std::lock_guard<std::recursive_mutex>
1635 lock(ScreenSessionManager::GetInstance().screenSessionMapMutex_);
1636 ScreenSessionManager::GetInstance().screenSessionMap_.erase(internalId);
1637 ScreenSessionManager::GetInstance().screenSessionMap_.erase(externalId);
1638 }
1639 }
1640
1641 /**
1642 * @tc.name: InternalScreenOffChange02
1643 * @tc.desc: no need to change or paramater error
1644 * @tc.type: FUNC
1645 */
1646 HWTEST_F(MultiScreenManagerTest, InternalScreenOffChange02, TestSize.Level1)
1647 {
1648 ScreenId internalId = 0;
1649 ScreenSessionConfig internalConfig = {
1650 .screenId = internalId,
1651 };
1652 sptr<ScreenSession> internalSession = new ScreenSession(internalConfig,
1653 ScreenSessionReason::CREATE_SESSION_FOR_REAL);
1654 internalSession->SetIsInternal(true);
1655 internalSession->SetIsExtend(true);
1656 internalSession->SetIsCurrentInUse(true);
1657 internalSession->SetScreenCombination(ScreenCombination::SCREEN_MIRROR);
1658 {
1659 std::lock_guard<std::recursive_mutex>
1660 lock(ScreenSessionManager::GetInstance().screenSessionMapMutex_);
1661 ScreenSessionManager::GetInstance().screenSessionMap_[internalId] = internalSession;
1662 }
1663
1664 ScreenId externalId = 11;
1665 ScreenSessionConfig externalConfig = {
1666 .screenId = externalId,
1667 };
1668 sptr<ScreenSession> externalSession = new ScreenSession(externalConfig,
1669 ScreenSessionReason::CREATE_SESSION_FOR_MIRROR);
1670 externalSession->SetIsInternal(false);
1671 externalSession->SetIsExtend(false);
1672 externalSession->SetIsCurrentInUse(true);
1673 externalSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
1674 {
1675 std::lock_guard<std::recursive_mutex>
1676 lock(ScreenSessionManager::GetInstance().screenSessionMapMutex_);
1677 ScreenSessionManager::GetInstance().screenSessionMap_[externalId] = externalSession;
1678 }
1679
1680 MultiScreenManager::GetInstance().InternalScreenOffChange(internalSession, externalSession);
1681
1682 EXPECT_EQ(true, internalSession->GetIsExtend());
1683 EXPECT_EQ(false, externalSession->GetIsExtend());
1684 EXPECT_EQ(ScreenCombination::SCREEN_MIRROR, internalSession->GetScreenCombination());
1685 EXPECT_EQ(ScreenCombination::SCREEN_MAIN, externalSession->GetScreenCombination());
1686 {
1687 std::lock_guard<std::recursive_mutex>
1688 lock(ScreenSessionManager::GetInstance().screenSessionMapMutex_);
1689 ScreenSessionManager::GetInstance().screenSessionMap_.erase(internalId);
1690 ScreenSessionManager::GetInstance().screenSessionMap_.erase(externalId);
1691 }
1692 }
1693
1694 /**
1695 * @tc.name: InternalScreenOffChange03
1696 * @tc.desc: internal extend to external mirror
1697 * @tc.type: FUNC
1698 */
1699 HWTEST_F(MultiScreenManagerTest, InternalScreenOffChange03, TestSize.Level1)
1700 {
1701 ScreenId internalId = 0;
1702 ScreenSessionConfig internalConfig = {
1703 .screenId = internalId,
1704 };
1705 sptr<ScreenSession> internalSession = new ScreenSession(internalConfig,
1706 ScreenSessionReason::CREATE_SESSION_FOR_REAL);
1707 internalSession->SetIsInternal(true);
1708 internalSession->SetIsExtend(false);
1709 internalSession->SetIsCurrentInUse(true);
1710 internalSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
1711 {
1712 std::lock_guard<std::recursive_mutex>
1713 lock(ScreenSessionManager::GetInstance().screenSessionMapMutex_);
1714 ScreenSessionManager::GetInstance().screenSessionMap_[internalId] = internalSession;
1715 }
1716
1717 ScreenId externalId = 11;
1718 ScreenSessionConfig externalConfig = {
1719 .screenId = externalId,
1720 };
1721 sptr<ScreenSession> externalSession = new ScreenSession(externalConfig,
1722 ScreenSessionReason::CREATE_SESSION_FOR_MIRROR);
1723 externalSession->SetIsInternal(false);
1724 externalSession->SetIsExtend(true);
1725 externalSession->SetIsCurrentInUse(true);
1726 externalSession->SetScreenCombination(ScreenCombination::SCREEN_EXTEND);
1727 {
1728 std::lock_guard<std::recursive_mutex>
1729 lock(ScreenSessionManager::GetInstance().screenSessionMapMutex_);
1730 ScreenSessionManager::GetInstance().screenSessionMap_[externalId] = externalSession;
1731 }
1732
1733 MultiScreenManager::GetInstance().InternalScreenOffChange(internalSession, externalSession);
1734
1735 EXPECT_EQ(true, internalSession->GetIsExtend());
1736 EXPECT_EQ(false, externalSession->GetIsExtend());
1737 EXPECT_EQ(ScreenCombination::SCREEN_MIRROR, internalSession->GetScreenCombination());
1738 EXPECT_EQ(ScreenCombination::SCREEN_MAIN, externalSession->GetScreenCombination());
1739 {
1740 std::lock_guard<std::recursive_mutex>
1741 lock(ScreenSessionManager::GetInstance().screenSessionMapMutex_);
1742 ScreenSessionManager::GetInstance().screenSessionMap_.erase(internalId);
1743 ScreenSessionManager::GetInstance().screenSessionMap_.erase(externalId);
1744 }
1745 }
1746
1747 /**
1748 * @tc.name: InternalScreenOffChange04
1749 * @tc.desc: external extend to external mirror
1750 * @tc.type: FUNC
1751 */
1752 HWTEST_F(MultiScreenManagerTest, InternalScreenOffChange04, TestSize.Level1)
1753 {
1754 ScreenId internalId = 0;
1755 ScreenSessionConfig internalConfig = {
1756 .screenId = internalId,
1757 };
1758 sptr<ScreenSession> internalSession = new ScreenSession(internalConfig,
1759 ScreenSessionReason::CREATE_SESSION_FOR_REAL);
1760 internalSession->SetIsInternal(true);
1761 internalSession->SetIsExtend(true);
1762 internalSession->SetIsCurrentInUse(true);
1763 internalSession->SetScreenCombination(ScreenCombination::SCREEN_EXTEND);
1764 {
1765 std::lock_guard<std::recursive_mutex>
1766 lock(ScreenSessionManager::GetInstance().screenSessionMapMutex_);
1767 ScreenSessionManager::GetInstance().screenSessionMap_[internalId] = internalSession;
1768 }
1769
1770 ScreenId externalId = 11;
1771 ScreenSessionConfig externalConfig = {
1772 .screenId = externalId,
1773 };
1774 sptr<ScreenSession> externalSession = new ScreenSession(externalConfig,
1775 ScreenSessionReason::CREATE_SESSION_FOR_MIRROR);
1776 externalSession->SetIsInternal(false);
1777 externalSession->SetIsExtend(false);
1778 externalSession->SetIsCurrentInUse(true);
1779 externalSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
1780 {
1781 std::lock_guard<std::recursive_mutex>
1782 lock(ScreenSessionManager::GetInstance().screenSessionMapMutex_);
1783 ScreenSessionManager::GetInstance().screenSessionMap_[externalId] = externalSession;
1784 }
1785
1786 MultiScreenManager::GetInstance().InternalScreenOffChange(internalSession, externalSession);
1787
1788 EXPECT_EQ(true, internalSession->GetIsExtend());
1789 EXPECT_EQ(false, externalSession->GetIsExtend());
1790 EXPECT_EQ(ScreenCombination::SCREEN_MIRROR, internalSession->GetScreenCombination());
1791 EXPECT_EQ(ScreenCombination::SCREEN_MAIN, externalSession->GetScreenCombination());
1792 {
1793 std::lock_guard<std::recursive_mutex>
1794 lock(ScreenSessionManager::GetInstance().screenSessionMapMutex_);
1795 ScreenSessionManager::GetInstance().screenSessionMap_.erase(internalId);
1796 ScreenSessionManager::GetInstance().screenSessionMap_.erase(externalId);
1797 }
1798 }
1799
1800 /**
1801 * @tc.name: InternalScreenOffChange05
1802 * @tc.desc: session nullptr
1803 * @tc.type: FUNC
1804 */
1805 HWTEST_F(MultiScreenManagerTest, InternalScreenOffChange05, TestSize.Level1)
1806 {
1807 ScreenId internalId = 0;
1808 ScreenSessionConfig internalConfig = {
1809 .screenId = internalId,
1810 };
1811 sptr<ScreenSession> internalSession = new ScreenSession(internalConfig,
1812 ScreenSessionReason::CREATE_SESSION_FOR_REAL);
1813 internalSession->SetIsInternal(true);
1814 internalSession->SetIsExtend(false);
1815 internalSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
1816 {
1817 std::lock_guard<std::recursive_mutex>
1818 lock(ScreenSessionManager::GetInstance().screenSessionMapMutex_);
1819 ScreenSessionManager::GetInstance().screenSessionMap_[internalId] = internalSession;
1820 }
1821
1822 sptr<ScreenSession> externalSession = nullptr;
1823
1824 ScreenId mainScreenId = internalId;
1825 MultiScreenMode secondaryScreenMode = MultiScreenMode::SCREEN_MIRROR;
1826 MultiScreenManager::GetInstance().SetLastScreenMode(mainScreenId, secondaryScreenMode);
1827 MultiScreenManager::GetInstance().InternalScreenOffChange(internalSession, externalSession);
1828
1829 EXPECT_EQ(false, internalSession->GetIsExtend());
1830 EXPECT_EQ(ScreenCombination::SCREEN_MAIN, internalSession->GetScreenCombination());
1831 {
1832 std::lock_guard<std::recursive_mutex>
1833 lock(ScreenSessionManager::GetInstance().screenSessionMapMutex_);
1834 ScreenSessionManager::GetInstance().screenSessionMap_.erase(internalId);
1835 }
1836 }
1837
1838 /**
1839 * @tc.name: ExternalScreenDisconnectChange01
1840 * @tc.desc: paramater error
1841 * @tc.type: FUNC
1842 */
1843 HWTEST_F(MultiScreenManagerTest, ExternalScreenDisconnectChange01, TestSize.Level1)
1844 {
1845 ScreenId internalId = 0;
1846 ScreenSessionConfig internalConfig = {
1847 .screenId = internalId,
1848 };
1849 sptr<ScreenSession> internalSession = new ScreenSession(internalConfig,
1850 ScreenSessionReason::CREATE_SESSION_FOR_REAL);
1851 internalSession->SetIsInternal(true);
1852 internalSession->SetIsExtend(false);
1853 internalSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
1854 {
1855 std::lock_guard<std::recursive_mutex>
1856 lock(ScreenSessionManager::GetInstance().screenSessionMapMutex_);
1857 ScreenSessionManager::GetInstance().screenSessionMap_[internalId] = internalSession;
1858 }
1859
1860 ScreenId externalId = 11;
1861 ScreenSessionConfig externalConfig = {
1862 .screenId = externalId,
1863 };
1864 sptr<ScreenSession> externalSession = new ScreenSession(externalConfig,
1865 ScreenSessionReason::CREATE_SESSION_FOR_MIRROR);
1866 externalSession->SetIsInternal(false);
1867 externalSession->SetIsExtend(true);
1868 externalSession->SetScreenCombination(ScreenCombination::SCREEN_MIRROR);
1869 {
1870 std::lock_guard<std::recursive_mutex>
1871 lock(ScreenSessionManager::GetInstance().screenSessionMapMutex_);
1872 ScreenSessionManager::GetInstance().screenSessionMap_[externalId] = externalSession;
1873 }
1874
1875 MultiScreenManager::GetInstance().ExternalScreenDisconnectChange(internalSession, externalSession);
1876
1877 EXPECT_EQ(false, internalSession->GetIsExtend());
1878 EXPECT_EQ(true, externalSession->GetIsExtend());
1879 EXPECT_EQ(ScreenCombination::SCREEN_MAIN, internalSession->GetScreenCombination());
1880 EXPECT_EQ(ScreenCombination::SCREEN_MIRROR, externalSession->GetScreenCombination());
1881 {
1882 std::lock_guard<std::recursive_mutex>
1883 lock(ScreenSessionManager::GetInstance().screenSessionMapMutex_);
1884 ScreenSessionManager::GetInstance().screenSessionMap_.erase(internalId);
1885 ScreenSessionManager::GetInstance().screenSessionMap_.erase(externalId);
1886 }
1887 }
1888
1889 /**
1890 * @tc.name: ExternalScreenDisconnectChange02
1891 * @tc.desc: external mirror to internal mirror
1892 * @tc.type: FUNC
1893 */
1894 HWTEST_F(MultiScreenManagerTest, ExternalScreenDisconnectChange02, TestSize.Level1)
1895 {
1896 ScreenId internalId = 0;
1897 ScreenSessionConfig internalConfig = {
1898 .screenId = internalId,
1899 };
1900 sptr<ScreenSession> internalSession = new ScreenSession(internalConfig,
1901 ScreenSessionReason::CREATE_SESSION_FOR_REAL);
1902 internalSession->SetIsInternal(true);
1903 internalSession->SetIsExtend(true);
1904 internalSession->SetScreenCombination(ScreenCombination::SCREEN_MIRROR);
1905 {
1906 std::lock_guard<std::recursive_mutex>
1907 lock(ScreenSessionManager::GetInstance().screenSessionMapMutex_);
1908 ScreenSessionManager::GetInstance().screenSessionMap_[internalId] = internalSession;
1909 }
1910
1911 ScreenId externalId = 11;
1912 ScreenSessionConfig externalConfig = {
1913 .screenId = externalId,
1914 };
1915 sptr<ScreenSession> externalSession = new ScreenSession(externalConfig,
1916 ScreenSessionReason::CREATE_SESSION_FOR_MIRROR);
1917 externalSession->SetIsInternal(false);
1918 externalSession->SetIsExtend(false);
1919 externalSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
1920 {
1921 std::lock_guard<std::recursive_mutex>
1922 lock(ScreenSessionManager::GetInstance().screenSessionMapMutex_);
1923 ScreenSessionManager::GetInstance().screenSessionMap_[externalId] = externalSession;
1924 }
1925
1926 MultiScreenManager::GetInstance().ExternalScreenDisconnectChange(internalSession, externalSession);
1927
1928 EXPECT_EQ(false, internalSession->GetIsExtend());
1929 EXPECT_EQ(true, externalSession->GetIsExtend());
1930 EXPECT_EQ(ScreenCombination::SCREEN_MAIN, internalSession->GetScreenCombination());
1931 EXPECT_EQ(ScreenCombination::SCREEN_MIRROR, externalSession->GetScreenCombination());
1932 {
1933 std::lock_guard<std::recursive_mutex>
1934 lock(ScreenSessionManager::GetInstance().screenSessionMapMutex_);
1935 ScreenSessionManager::GetInstance().screenSessionMap_.erase(internalId);
1936 ScreenSessionManager::GetInstance().screenSessionMap_.erase(externalId);
1937 }
1938 }
1939
1940 /**
1941 * @tc.name: ExternalScreenDisconnectChange03
1942 * @tc.desc: internal extend to internal mirror
1943 * @tc.type: FUNC
1944 */
1945 HWTEST_F(MultiScreenManagerTest, ExternalScreenDisconnectChange03, TestSize.Level1)
1946 {
1947 ScreenId internalId = 0;
1948 ScreenSessionConfig internalConfig = {
1949 .screenId = internalId,
1950 };
1951 sptr<ScreenSession> internalSession = new ScreenSession(internalConfig,
1952 ScreenSessionReason::CREATE_SESSION_FOR_REAL);
1953 internalSession->SetIsInternal(true);
1954 internalSession->SetIsExtend(false);
1955 internalSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
1956 {
1957 std::lock_guard<std::recursive_mutex>
1958 lock(ScreenSessionManager::GetInstance().screenSessionMapMutex_);
1959 ScreenSessionManager::GetInstance().screenSessionMap_[internalId] = internalSession;
1960 }
1961
1962 ScreenId externalId = 11;
1963 ScreenSessionConfig externalConfig = {
1964 .screenId = externalId,
1965 };
1966 sptr<ScreenSession> externalSession = new ScreenSession(externalConfig,
1967 ScreenSessionReason::CREATE_SESSION_FOR_MIRROR);
1968 externalSession->SetIsInternal(false);
1969 externalSession->SetIsExtend(true);
1970 externalSession->SetScreenCombination(ScreenCombination::SCREEN_EXTEND);
1971 {
1972 std::lock_guard<std::recursive_mutex>
1973 lock(ScreenSessionManager::GetInstance().screenSessionMapMutex_);
1974 ScreenSessionManager::GetInstance().screenSessionMap_[externalId] = externalSession;
1975 }
1976
1977 MultiScreenManager::GetInstance().ExternalScreenDisconnectChange(internalSession, externalSession);
1978
1979 EXPECT_EQ(false, internalSession->GetIsExtend());
1980 EXPECT_EQ(true, externalSession->GetIsExtend());
1981 EXPECT_EQ(ScreenCombination::SCREEN_MAIN, internalSession->GetScreenCombination());
1982 EXPECT_EQ(ScreenCombination::SCREEN_MIRROR, externalSession->GetScreenCombination());
1983 {
1984 std::lock_guard<std::recursive_mutex>
1985 lock(ScreenSessionManager::GetInstance().screenSessionMapMutex_);
1986 ScreenSessionManager::GetInstance().screenSessionMap_.erase(internalId);
1987 ScreenSessionManager::GetInstance().screenSessionMap_.erase(externalId);
1988 }
1989 }
1990
1991 /**
1992 * @tc.name: ExternalScreenDisconnectChange04
1993 * @tc.desc: external extend to internal mirror
1994 * @tc.type: FUNC
1995 */
1996 HWTEST_F(MultiScreenManagerTest, ExternalScreenDisconnectChange04, TestSize.Level1)
1997 {
1998 ScreenId internalId = 0;
1999 ScreenSessionConfig internalConfig = {
2000 .screenId = internalId,
2001 };
2002 sptr<ScreenSession> internalSession = new ScreenSession(internalConfig,
2003 ScreenSessionReason::CREATE_SESSION_FOR_REAL);
2004 internalSession->SetIsInternal(true);
2005 internalSession->SetIsExtend(true);
2006 internalSession->SetScreenCombination(ScreenCombination::SCREEN_EXTEND);
2007 {
2008 std::lock_guard<std::recursive_mutex>
2009 lock(ScreenSessionManager::GetInstance().screenSessionMapMutex_);
2010 ScreenSessionManager::GetInstance().screenSessionMap_[internalId] = internalSession;
2011 }
2012
2013 ScreenId externalId = 11;
2014 ScreenSessionConfig externalConfig = {
2015 .screenId = externalId,
2016 };
2017 sptr<ScreenSession> externalSession = new ScreenSession(externalConfig,
2018 ScreenSessionReason::CREATE_SESSION_FOR_MIRROR);
2019 externalSession->SetIsInternal(false);
2020 externalSession->SetIsExtend(false);
2021 externalSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
2022 {
2023 std::lock_guard<std::recursive_mutex>
2024 lock(ScreenSessionManager::GetInstance().screenSessionMapMutex_);
2025 ScreenSessionManager::GetInstance().screenSessionMap_[externalId] = externalSession;
2026 }
2027
2028 MultiScreenManager::GetInstance().ExternalScreenDisconnectChange(internalSession, externalSession);
2029
2030 EXPECT_EQ(false, internalSession->GetIsExtend());
2031 EXPECT_EQ(true, externalSession->GetIsExtend());
2032 EXPECT_EQ(ScreenCombination::SCREEN_MAIN, internalSession->GetScreenCombination());
2033 EXPECT_EQ(ScreenCombination::SCREEN_MIRROR, externalSession->GetScreenCombination());
2034 {
2035 std::lock_guard<std::recursive_mutex>
2036 lock(ScreenSessionManager::GetInstance().screenSessionMapMutex_);
2037 ScreenSessionManager::GetInstance().screenSessionMap_.erase(internalId);
2038 ScreenSessionManager::GetInstance().screenSessionMap_.erase(externalId);
2039 }
2040 }
2041
2042 /**
2043 * @tc.name: ExternalScreenDisconnectChange05
2044 * @tc.desc: session nullptr
2045 * @tc.type: FUNC
2046 */
2047 HWTEST_F(MultiScreenManagerTest, ExternalScreenDisconnectChange05, TestSize.Level1)
2048 {
2049 ScreenId internalId = 0;
2050 ScreenSessionConfig internalConfig = {
2051 .screenId = internalId,
2052 };
2053 sptr<ScreenSession> internalSession = new ScreenSession(internalConfig,
2054 ScreenSessionReason::CREATE_SESSION_FOR_REAL);
2055 internalSession->SetIsInternal(true);
2056 internalSession->SetIsExtend(false);
2057 internalSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
2058 {
2059 std::lock_guard<std::recursive_mutex>
2060 lock(ScreenSessionManager::GetInstance().screenSessionMapMutex_);
2061 ScreenSessionManager::GetInstance().screenSessionMap_[internalId] = internalSession;
2062 }
2063
2064 sptr<ScreenSession> externalSession = nullptr;
2065
2066 MultiScreenManager::GetInstance().ExternalScreenDisconnectChange(internalSession, externalSession);
2067
2068 EXPECT_EQ(false, internalSession->GetIsExtend());
2069 EXPECT_EQ(ScreenCombination::SCREEN_MAIN, internalSession->GetScreenCombination());
2070 {
2071 std::lock_guard<std::recursive_mutex>
2072 lock(ScreenSessionManager::GetInstance().screenSessionMapMutex_);
2073 ScreenSessionManager::GetInstance().screenSessionMap_.erase(internalId);
2074 }
2075 }
2076
2077 /**
2078 * @tc.name: AreScreensTouching
2079 * @tc.desc: A is located to the left of B
2080 * @tc.type: FUNC
2081 */
2082 HWTEST_F(MultiScreenManagerTest, AreScreensTouching01, TestSize.Level1)
2083 {
2084 ScreenProperty mainProperty = ScreenProperty();
2085 RRect mainBounds;
2086 mainBounds.rect_.width_ = 200;
2087 mainBounds.rect_.height_ = 100;
2088 mainProperty.SetBounds(mainBounds);
2089 DisplayId mainScreenId = 0;
2090 sptr<ScreenSession> mainScreenSession = new (std::nothrow) ScreenSession(mainScreenId, mainProperty, 0);
2091 ASSERT_NE(mainScreenSession, nullptr);
2092
2093 ScreenProperty secondProperty = ScreenProperty();
2094 RRect secondBounds;
2095 secondBounds.rect_.width_ = 200;
2096 secondBounds.rect_.height_ = 100;
2097 secondProperty.SetBounds(secondBounds);
2098 DisplayId secondScreenId = 1;
2099 sptr<ScreenSession> secondScreenSession = new (std::nothrow) ScreenSession(secondScreenId, secondProperty, 0);
2100 ASSERT_NE(secondScreenSession, nullptr);
2101
2102 MultiScreenPositionOptions mainScreenOptions = {mainScreenId, 0, 0};
2103 MultiScreenPositionOptions secondScreenOption = {secondScreenId, 200, 0};
2104 auto ret = MultiScreenManager::GetInstance().AreScreensTouching(mainScreenSession, secondScreenSession,
2105 mainScreenOptions, secondScreenOption);
2106 ASSERT_EQ(ret, true);
2107 }
2108
2109 /**
2110 * @tc.name: AreScreensTouching
2111 * @tc.desc: B is located to the left of A
2112 * @tc.type: FUNC
2113 */
2114 HWTEST_F(MultiScreenManagerTest, AreScreensTouching02, TestSize.Level1)
2115 {
2116 ScreenProperty mainProperty = ScreenProperty();
2117 RRect mainBounds;
2118 mainBounds.rect_.width_ = 200;
2119 mainBounds.rect_.height_ = 100;
2120 mainProperty.SetBounds(mainBounds);
2121 DisplayId mainScreenId = 0;
2122 sptr<ScreenSession> mainScreenSession = new (std::nothrow) ScreenSession(mainScreenId, mainProperty, 0);
2123 ASSERT_NE(mainScreenSession, nullptr);
2124
2125 ScreenProperty secondProperty = ScreenProperty();
2126 RRect secondBounds;
2127 secondBounds.rect_.width_ = 200;
2128 secondBounds.rect_.height_ = 100;
2129 secondProperty.SetBounds(secondBounds);
2130 DisplayId secondScreenId = 1;
2131 sptr<ScreenSession> secondScreenSession = new (std::nothrow) ScreenSession(secondScreenId, secondProperty, 0);
2132 ASSERT_NE(secondScreenSession, nullptr);
2133
2134 MultiScreenPositionOptions mainScreenOptions = {mainScreenId, 200, 0};
2135 MultiScreenPositionOptions secondScreenOption = {secondScreenId, 0, 0};
2136 auto ret = MultiScreenManager::GetInstance().AreScreensTouching(mainScreenSession, secondScreenSession,
2137 mainScreenOptions, secondScreenOption);
2138 ASSERT_EQ(ret, true);
2139 }
2140
2141 /**
2142 * @tc.name: AreScreensTouching
2143 * @tc.desc: A is located to the upper of B
2144 * @tc.type: FUNC
2145 */
2146 HWTEST_F(MultiScreenManagerTest, AreScreensTouching03, TestSize.Level1)
2147 {
2148 ScreenProperty mainProperty = ScreenProperty();
2149 RRect mainBounds;
2150 mainBounds.rect_.width_ = 200;
2151 mainBounds.rect_.height_ = 100;
2152 mainProperty.SetBounds(mainBounds);
2153 DisplayId mainScreenId = 0;
2154 sptr<ScreenSession> mainScreenSession = new (std::nothrow) ScreenSession(mainScreenId, mainProperty, 0);
2155 ASSERT_NE(mainScreenSession, nullptr);
2156
2157 ScreenProperty secondProperty = ScreenProperty();
2158 RRect secondBounds;
2159 secondBounds.rect_.width_ = 200;
2160 secondBounds.rect_.height_ = 100;
2161 secondProperty.SetBounds(secondBounds);
2162 DisplayId secondScreenId = 1;
2163 sptr<ScreenSession> secondScreenSession = new (std::nothrow) ScreenSession(secondScreenId, secondProperty, 0);
2164 ASSERT_NE(secondScreenSession, nullptr);
2165
2166 MultiScreenPositionOptions mainScreenOptions = {mainScreenId, 0, 0};
2167 MultiScreenPositionOptions secondScreenOption = {secondScreenId, 0, 100};
2168 auto ret = MultiScreenManager::GetInstance().AreScreensTouching(mainScreenSession, secondScreenSession,
2169 mainScreenOptions, secondScreenOption);
2170 ASSERT_EQ(ret, true);
2171 }
2172
2173 /**
2174 * @tc.name: AreScreensTouching
2175 * @tc.desc: B is located to the upper of A
2176 * @tc.type: FUNC
2177 */
2178 HWTEST_F(MultiScreenManagerTest, AreScreensTouching04, TestSize.Level1)
2179 {
2180 ScreenProperty mainProperty = ScreenProperty();
2181 RRect mainBounds;
2182 mainBounds.rect_.width_ = 200;
2183 mainBounds.rect_.height_ = 100;
2184 mainProperty.SetBounds(mainBounds);
2185 DisplayId mainScreenId = 0;
2186 sptr<ScreenSession> mainScreenSession = new (std::nothrow) ScreenSession(mainScreenId, mainProperty, 0);
2187 ASSERT_NE(mainScreenSession, nullptr);
2188
2189 ScreenProperty secondProperty = ScreenProperty();
2190 RRect secondBounds;
2191 secondBounds.rect_.width_ = 200;
2192 secondBounds.rect_.height_ = 100;
2193 secondProperty.SetBounds(secondBounds);
2194 DisplayId secondScreenId = 1;
2195 sptr<ScreenSession> secondScreenSession = new (std::nothrow) ScreenSession(secondScreenId, secondProperty, 0);
2196 ASSERT_NE(secondScreenSession, nullptr);
2197
2198 MultiScreenPositionOptions mainScreenOptions = {mainScreenId, 0, 100};
2199 MultiScreenPositionOptions secondScreenOption = {secondScreenId, 0, 0};
2200 auto ret = MultiScreenManager::GetInstance().AreScreensTouching(mainScreenSession, secondScreenSession,
2201 mainScreenOptions, secondScreenOption);
2202 ASSERT_EQ(ret, true);
2203 }
2204
2205 /**
2206 * @tc.name: AreScreensTouching
2207 * @tc.desc: B is located in the lower right corner of A
2208 * @tc.type: FUNC
2209 */
2210 HWTEST_F(MultiScreenManagerTest, AreScreensTouching05, TestSize.Level1)
2211 {
2212 ScreenProperty mainProperty = ScreenProperty();
2213 RRect mainBounds;
2214 mainBounds.rect_.width_ = 200;
2215 mainBounds.rect_.height_ = 100;
2216 mainProperty.SetBounds(mainBounds);
2217 DisplayId mainScreenId = 0;
2218 sptr<ScreenSession> mainScreenSession = new (std::nothrow) ScreenSession(mainScreenId, mainProperty, 0);
2219 ASSERT_NE(mainScreenSession, nullptr);
2220
2221 ScreenProperty secondProperty = ScreenProperty();
2222 RRect secondBounds;
2223 secondBounds.rect_.width_ = 200;
2224 secondBounds.rect_.height_ = 100;
2225 secondProperty.SetBounds(secondBounds);
2226 DisplayId secondScreenId = 1;
2227 sptr<ScreenSession> secondScreenSession = new (std::nothrow) ScreenSession(secondScreenId, secondProperty, 0);
2228 ASSERT_NE(secondScreenSession, nullptr);
2229
2230 MultiScreenPositionOptions mainScreenOptions = {mainScreenId, 0, 0};
2231 MultiScreenPositionOptions secondScreenOption = {secondScreenId, 200, 100};
2232 auto ret = MultiScreenManager::GetInstance().AreScreensTouching(mainScreenSession, secondScreenSession,
2233 mainScreenOptions, secondScreenOption);
2234 ASSERT_EQ(ret, false);
2235 }
2236
2237 /**
2238 * @tc.name: AreScreensTouching
2239 * @tc.desc: A is located in the lower right corner of B
2240 * @tc.type: FUNC
2241 */
2242 HWTEST_F(MultiScreenManagerTest, AreScreensTouching06, TestSize.Level1)
2243 {
2244 ScreenProperty mainProperty = ScreenProperty();
2245 RRect mainBounds;
2246 mainBounds.rect_.width_ = 200;
2247 mainBounds.rect_.height_ = 100;
2248 mainProperty.SetBounds(mainBounds);
2249 DisplayId mainScreenId = 0;
2250 sptr<ScreenSession> mainScreenSession = new (std::nothrow) ScreenSession(mainScreenId, mainProperty, 0);
2251 ASSERT_NE(mainScreenSession, nullptr);
2252
2253 ScreenProperty secondProperty = ScreenProperty();
2254 RRect secondBounds;
2255 secondBounds.rect_.width_ = 200;
2256 secondBounds.rect_.height_ = 100;
2257 secondProperty.SetBounds(secondBounds);
2258 DisplayId secondScreenId = 1;
2259 sptr<ScreenSession> secondScreenSession = new (std::nothrow) ScreenSession(secondScreenId, secondProperty, 0);
2260 ASSERT_NE(secondScreenSession, nullptr);
2261
2262 MultiScreenPositionOptions mainScreenOptions = {mainScreenId, 200, 100};
2263 MultiScreenPositionOptions secondScreenOption = {secondScreenId, 0, 0};
2264 auto ret = MultiScreenManager::GetInstance().AreScreensTouching(mainScreenSession, secondScreenSession,
2265 mainScreenOptions, secondScreenOption);
2266 ASSERT_EQ(ret, false);
2267 }
2268
2269 /**
2270 * @tc.name: AreScreensTouching
2271 * @tc.desc: B has no contact with A
2272 * @tc.type: FUNC
2273 */
2274 HWTEST_F(MultiScreenManagerTest, AreScreensTouching07, TestSize.Level1)
2275 {
2276 ScreenProperty mainProperty = ScreenProperty();
2277 RRect mainBounds;
2278 mainBounds.rect_.width_ = 200;
2279 mainBounds.rect_.height_ = 100;
2280 mainProperty.SetBounds(mainBounds);
2281 DisplayId mainScreenId = 0;
2282 sptr<ScreenSession> mainScreenSession = new (std::nothrow) ScreenSession(mainScreenId, mainProperty, 0);
2283 ASSERT_NE(mainScreenSession, nullptr);
2284
2285 ScreenProperty secondProperty = ScreenProperty();
2286 RRect secondBounds;
2287 secondBounds.rect_.width_ = 200;
2288 secondBounds.rect_.height_ = 100;
2289 secondProperty.SetBounds(secondBounds);
2290 DisplayId secondScreenId = 1;
2291 sptr<ScreenSession> secondScreenSession = new (std::nothrow) ScreenSession(secondScreenId, secondProperty, 0);
2292 ASSERT_NE(secondScreenSession, nullptr);
2293
2294 MultiScreenPositionOptions mainScreenOptions = {mainScreenId, 0, 0};
2295 MultiScreenPositionOptions secondScreenOption = {secondScreenId, 300, 0};
2296 auto ret = MultiScreenManager::GetInstance().AreScreensTouching(mainScreenSession, secondScreenSession,
2297 mainScreenOptions, secondScreenOption);
2298 ASSERT_EQ(ret, false);
2299 }
2300
2301 /**
2302 * @tc.name: AreScreensTouching
2303 * @tc.desc: B has no contact with A
2304 * @tc.type: FUNC
2305 */
2306 HWTEST_F(MultiScreenManagerTest, AreScreensTouching08, TestSize.Level1)
2307 {
2308 ScreenProperty mainProperty = ScreenProperty();
2309 RRect mainBounds;
2310 mainBounds.rect_.width_ = 200;
2311 mainBounds.rect_.height_ = 100;
2312 mainProperty.SetBounds(mainBounds);
2313 DisplayId mainScreenId = 0;
2314 sptr<ScreenSession> mainScreenSession = new (std::nothrow) ScreenSession(mainScreenId, mainProperty, 0);
2315 ASSERT_NE(mainScreenSession, nullptr);
2316
2317 ScreenProperty secondProperty = ScreenProperty();
2318 RRect secondBounds;
2319 secondBounds.rect_.width_ = 200;
2320 secondBounds.rect_.height_ = 100;
2321 secondProperty.SetBounds(secondBounds);
2322 DisplayId secondScreenId = 1;
2323 sptr<ScreenSession> secondScreenSession = new (std::nothrow) ScreenSession(secondScreenId, secondProperty, 0);
2324 ASSERT_NE(secondScreenSession, nullptr);
2325
2326 MultiScreenPositionOptions mainScreenOptions = {mainScreenId, 0, 0};
2327 MultiScreenPositionOptions secondScreenOption = {secondScreenId, 0, 200};
2328 auto ret = MultiScreenManager::GetInstance().AreScreensTouching(mainScreenSession, secondScreenSession,
2329 mainScreenOptions, secondScreenOption);
2330 ASSERT_EQ(ret, false);
2331 }
2332 }
2333 } // namespace Rosen
2334 } // namespace OHOS
2335