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