1 /*
2 * Copyright (c) 2023-2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include "picture_in_picture_manager.h"
18 #include "scene_board_judgement.h"
19 #include "singleton_container.h"
20 #include "window_scene_session_impl.h"
21 #include "wm_common.h"
22
23 using namespace testing;
24 using namespace testing::ext;
25
26 namespace OHOS {
27 namespace Rosen {
28 class PictureInPictureManagerTest : public testing::Test {
29 public:
30 static void SetUpTestCase();
31 static void TearDownTestCase();
32 void SetUp() override;
33 void TearDown() override;
34 };
35
36 class MockWindow : public Window {
37 public:
MockWindow()38 MockWindow() {};
~MockWindow()39 ~MockWindow() {};
40 };
41
SetUpTestCase()42 void PictureInPictureManagerTest::SetUpTestCase() {}
43
TearDownTestCase()44 void PictureInPictureManagerTest::TearDownTestCase() {}
45
SetUp()46 void PictureInPictureManagerTest::SetUp() {}
47
TearDown()48 void PictureInPictureManagerTest::TearDown() {}
49
50 namespace {
51
52 /**
53 * @tc.name: IsSupportPiP
54 * @tc.desc: IsSupportPiP
55 * @tc.type: FUNC
56 */
57 HWTEST_F(PictureInPictureManagerTest, IsSupportPiP, Function | SmallTest | Level2)
58 {
59 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
60 ASSERT_EQ(true, PictureInPictureManager::IsSupportPiP());
61 } else {
62 ASSERT_EQ(false, PictureInPictureManager::IsSupportPiP());
63 }
64 }
65
66 /**
67 * @tc.name: PiPWindowState
68 * @tc.desc: PutPipControllerInfo/RemovePipControllerInfo/ReportPiPStartWindow/ReportPiPStopWindow/ReportPiPActionEvent
69 * @tc.type: FUNC
70 */
71 HWTEST_F(PictureInPictureManagerTest, PipControllerInfo, Function | SmallTest | Level2)
72 {
73 sptr<PipOption> option = new PipOption();
74 sptr<PictureInPictureController> pipController = new PictureInPictureController(option, nullptr, 100, nullptr);
75 PictureInPictureManager::PutPipControllerInfo(100, pipController);
76 ASSERT_EQ(1, static_cast<int>(PictureInPictureManager::windowToControllerMap_.size()));
77 PictureInPictureManager::RemovePipControllerInfo(100);
78 ASSERT_EQ(0, static_cast<int>(PictureInPictureManager::windowToControllerMap_.size()));
79 int32_t source = 0;
80 std::string errorReason = "";
81 SingletonContainer::Get<PiPReporter>().ReportPiPStartWindow(source, 1, 1, errorReason);
82 SingletonContainer::Get<PiPReporter>().ReportPiPStopWindow(source, 1, 1, errorReason);
83 source = 1;
84 SingletonContainer::Get<PiPReporter>().ReportPiPStartWindow(source, 1, 1, errorReason);
85 SingletonContainer::Get<PiPReporter>().ReportPiPStopWindow(source, 1, 1, errorReason);
86 std::string actionEvent = "";
87 SingletonContainer::Get<PiPReporter>().ReportPiPActionEvent(1, actionEvent);
88 actionEvent = "nextVideo";
89 SingletonContainer::Get<PiPReporter>().ReportPiPActionEvent(1, actionEvent);
90 }
91
92 /**
93 * @tc.name: PictureInPictureController
94 * @tc.desc: SetActiveController/IsActiveController/HasActiveController/RemoveActiveController
95 * @tc.type: FUNC
96 */
97 HWTEST_F(PictureInPictureManagerTest, PictureInPictureController, Function | SmallTest | Level2)
98 {
99 sptr<PipOption> option = new PipOption();
100 sptr<PictureInPictureController> pipController = new PictureInPictureController(option, nullptr, 100, nullptr);
101 PictureInPictureManager::activeController_ = nullptr;
102 ASSERT_FALSE(PictureInPictureManager::HasActiveController());
103 PictureInPictureManager::RemoveActiveController(pipController);
104 ASSERT_FALSE(PictureInPictureManager::HasActiveController());
105 ASSERT_FALSE(PictureInPictureManager::IsActiveController(pipController));
106
107 PictureInPictureManager::SetActiveController(pipController);
108 ASSERT_TRUE(PictureInPictureManager::HasActiveController());
109 ASSERT_TRUE(PictureInPictureManager::IsActiveController(pipController));
110 ASSERT_TRUE(PictureInPictureManager::IsAttachedToSameWindow(100));
111 ASSERT_FALSE(PictureInPictureManager::IsAttachedToSameWindow(1));
112 PictureInPictureManager::RemoveActiveController(pipController);
113 ASSERT_FALSE(PictureInPictureManager::HasActiveController());
114 ASSERT_FALSE(PictureInPictureManager::IsActiveController(pipController));
115 }
116
117 /**
118 * @tc.name: ShouldAbortPipStart
119 * @tc.desc: ShouldAbortPipStart
120 * @tc.type: FUNC
121 */
122 HWTEST_F(PictureInPictureManagerTest, ShouldAbortPipStart, Function | SmallTest | Level2)
123 {
124 ASSERT_FALSE(PictureInPictureManager::ShouldAbortPipStart());
125
126 sptr<PipOption> option = new (std::nothrow) PipOption();
127 ASSERT_NE(nullptr, option);
128 sptr<PictureInPictureController> pipController =
129 new (std::nothrow) PictureInPictureController(option, nullptr, 100, nullptr);
130 ASSERT_NE(pipController, nullptr);
131 PictureInPictureManager::SetActiveController(pipController);
132 pipController->curState_ = PiPWindowState::STATE_STARTING;
133
134 ASSERT_TRUE(PictureInPictureManager::ShouldAbortPipStart());
135 }
136
137 /**
138 * @tc.name: GetPipControllerInfo
139 * @tc.desc: GetPipControllerInfo
140 * @tc.type: FUNC
141 */
142 HWTEST_F(PictureInPictureManagerTest, GetPipControllerInfo, Function | SmallTest | Level2)
143 {
144 sptr<PipOption> option = new (std::nothrow) PipOption();
145 ASSERT_NE(nullptr, option);
146 sptr<PictureInPictureController> pipController =
147 new (std::nothrow) PictureInPictureController(option, nullptr, 100, nullptr);
148 ASSERT_NE(pipController, nullptr);
149 PictureInPictureManager::SetActiveController(pipController);
150 int32_t windowId = 1;
151 ASSERT_EQ(nullptr, PictureInPictureManager::GetPipControllerInfo(windowId));
152
153 sptr<PictureInPictureController> pipController1 =
154 new (std::nothrow) PictureInPictureController(option, nullptr, 100, nullptr);
155 ASSERT_NE(pipController1, nullptr);
156 PictureInPictureManager::windowToControllerMap_.insert(std::make_pair(windowId, pipController1));
157 ASSERT_EQ(pipController1, PictureInPictureManager::GetPipControllerInfo(windowId));
158 }
159
160 /**
161 * @tc.name: GetActiveController
162 * @tc.desc: GetActiveController
163 * @tc.type: FUNC
164 */
165 HWTEST_F(PictureInPictureManagerTest, GetActiveController, Function | SmallTest | Level2)
166 {
167 sptr<PipOption> option = new (std::nothrow) PipOption();
168 ASSERT_NE(nullptr, option);
169 sptr<PictureInPictureController> pipController =
170 new (std::nothrow) PictureInPictureController(option, nullptr, 100, nullptr);
171 ASSERT_NE(pipController, nullptr);
172 PictureInPictureManager::SetActiveController(pipController);
173 ASSERT_EQ(pipController, PictureInPictureManager::GetActiveController());
174
175 PictureInPictureManager::SetActiveController(nullptr);
176 ASSERT_EQ(nullptr, PictureInPictureManager::GetActiveController());
177 }
178
179 /**
180 * @tc.name: AttachAutoStartController
181 * @tc.desc: AttachAutoStartController
182 * @tc.type: FUNC
183 */
184 HWTEST_F(PictureInPictureManagerTest, AttachAutoStartController, Function | SmallTest | Level2)
185 {
186 PictureInPictureManager::AttachAutoStartController(0, nullptr);
187 sptr<PipOption> option = new (std::nothrow) PipOption();
188 ASSERT_NE(nullptr, option);
189 sptr<PictureInPictureController> pipController =
190 new (std::nothrow) PictureInPictureController(option, nullptr, 100, nullptr);
191 ASSERT_NE(pipController, nullptr);
192 PictureInPictureManager::SetActiveController(pipController);
193 wptr<PictureInPictureController> pipController1 =
194 new (std::nothrow) PictureInPictureController(option, nullptr, 100, nullptr);
195 ASSERT_NE(pipController1, nullptr);
196 PictureInPictureManager::AttachAutoStartController(1, pipController1);
197 ASSERT_EQ(pipController1, PictureInPictureManager::autoStartControllerMap_[1]);
198 }
199
200 /**
201 * @tc.name: DetachAutoStartController
202 * @tc.desc: DetachAutoStartController
203 * @tc.type: FUNC
204 */
205 HWTEST_F(PictureInPictureManagerTest, DetachAutoStartController, Function | SmallTest | Level2)
206 {
207 sptr<PipOption> option = new (std::nothrow) PipOption();
208 ASSERT_NE(nullptr, option);
209 wptr<PictureInPictureController> pipController =
210 new (std::nothrow) PictureInPictureController(option, nullptr, 100, nullptr);
211 ASSERT_NE(pipController, nullptr);
212 wptr<PictureInPictureController> pipController1 =
213 new (std::nothrow) PictureInPictureController(option, nullptr, 100, nullptr);
214 ASSERT_NE(pipController1, nullptr);
215 PictureInPictureManager::AttachAutoStartController(0, pipController);
216 PictureInPictureManager::AttachAutoStartController(1, pipController1);
217 ASSERT_EQ(2, PictureInPictureManager::autoStartControllerMap_.size());
218 PictureInPictureManager::DetachAutoStartController(0, nullptr);
219 ASSERT_EQ(1, PictureInPictureManager::autoStartControllerMap_.size());
220 PictureInPictureManager::DetachAutoStartController(0, pipController);
221 ASSERT_EQ(1, PictureInPictureManager::autoStartControllerMap_.size());
222 }
223
224 /**
225 * @tc.name: IsAttachedToSameWindow
226 * @tc.desc: IsAttachedToSameWindow
227 * @tc.type: FUNC
228 */
229 HWTEST_F(PictureInPictureManagerTest, IsAttachedToSameWindow, Function | SmallTest | Level2)
230 {
231 bool res = PictureInPictureManager::IsAttachedToSameWindow(0);
232 ASSERT_EQ(res, false);
233
234 sptr<PipOption> option = new (std::nothrow) PipOption();
235 ASSERT_NE(nullptr, option);
236 sptr<PictureInPictureController> pipController =
237 new (std::nothrow) PictureInPictureController(option, nullptr, 100, nullptr);
238 ASSERT_NE(pipController, nullptr);
239
240 PictureInPictureManager::activeController_ = nullptr;
241 ASSERT_FALSE(PictureInPictureManager::HasActiveController());
242 bool res1 = PictureInPictureManager::IsAttachedToSameWindow(1);
243 ASSERT_EQ(res1, false);
244
245 PictureInPictureManager::SetActiveController(pipController);
246 bool res2 = PictureInPictureManager::IsAttachedToSameWindow(100);
247 ASSERT_EQ(res2, true);
248 bool res3 = PictureInPictureManager::IsAttachedToSameWindow(1);
249 ASSERT_EQ(res3, false);
250 }
251
252 /**
253 * @tc.name: GetCurrentWindow
254 * @tc.desc: GetCurrentWindow
255 * @tc.type: FUNC
256 */
257 HWTEST_F(PictureInPictureManagerTest, GetCurrentWindow, Function | SmallTest | Level2)
258 {
259 ASSERT_EQ(nullptr, PictureInPictureManager::GetCurrentWindow());
260
261 sptr<PipOption> option = new (std::nothrow) PipOption();
262 ASSERT_NE(nullptr, option);
263 sptr<PictureInPictureController> pipController =
264 new (std::nothrow) PictureInPictureController(option, nullptr, 100, nullptr);
265 ASSERT_NE(pipController, nullptr);
266
267 PictureInPictureManager::activeController_ = nullptr;
268 ASSERT_FALSE(PictureInPictureManager::HasActiveController());
269 ASSERT_EQ(nullptr, PictureInPictureManager::GetCurrentWindow());
270
271 sptr<Window> window = nullptr;
272 ASSERT_EQ(window, pipController->window_);
273 PictureInPictureManager::SetActiveController(pipController);
274 window = PictureInPictureManager::GetCurrentWindow();
275 ASSERT_EQ(window, pipController->window_);
276 }
277
278 /**
279 * @tc.name: DoPreRestore
280 * @tc.desc: DoPreRestore
281 * @tc.type: FUNC
282 */
283 HWTEST_F(PictureInPictureManagerTest, DoPreRestore, Function | SmallTest | Level2)
284 {
285 auto mw = sptr<MockWindow>::MakeSptr();
286 ASSERT_NE(nullptr, mw);
287 auto option = sptr<PipOption>::MakeSptr();
288 ASSERT_NE(nullptr, option);
289 auto pipController = sptr<PictureInPictureController>::MakeSptr(option, nullptr, 100, nullptr);
290 ASSERT_NE(pipController, nullptr);
291 pipController->curState_ = PiPWindowState::STATE_STARTED;
292 PictureInPictureManager::activeController_ = nullptr;
293 PictureInPictureManager::DoPreRestore();
294 ASSERT_EQ(pipController->curState_, PiPWindowState::STATE_STARTED);
295 PictureInPictureManager::SetActiveController(pipController);
296 PictureInPictureManager::DoPreRestore();
297 ASSERT_EQ(pipController->curState_, PiPWindowState::STATE_RESTORING);
298 }
299
300 /**
301 * @tc.name: DoPrepareSource
302 * @tc.desc: DoPrepareSource
303 * @tc.type: FUNC
304 */
305 HWTEST_F(PictureInPictureManagerTest, DoPrepareSource, Function | SmallTest | Level2)
306 {
307 auto mw = sptr<MockWindow>::MakeSptr();
308 ASSERT_NE(nullptr, mw);
309 auto option = sptr<PipOption>::MakeSptr();
310 ASSERT_NE(nullptr, option);
311 auto pipController = sptr<PictureInPictureController>::MakeSptr(option, nullptr, 100, nullptr);
312 ASSERT_NE(pipController, nullptr);
313 PictureInPictureManager::activeController_ = nullptr;
314 PictureInPictureManager::DoPrepareSource();
315 PictureInPictureManager::SetActiveController(pipController);
316 PictureInPictureManager::DoPrepareSource();
317 }
318
319 /**
320 * @tc.name: DoLocateSource
321 * @tc.desc: DoLocateSource
322 * @tc.type: FUNC
323 */
324 HWTEST_F(PictureInPictureManagerTest, DoLocateSource, Function | SmallTest | Level2)
325 {
326 auto mw = sptr<MockWindow>::MakeSptr();
327 ASSERT_NE(nullptr, mw);
328 auto option = sptr<PipOption>::MakeSptr();
329 ASSERT_NE(nullptr, option);
330 auto pipController = sptr<PictureInPictureController>::MakeSptr(option, nullptr, 100, nullptr);
331 ASSERT_NE(pipController, nullptr);
332 PictureInPictureManager::activeController_ = nullptr;
333 PictureInPictureManager::DoLocateSource();
334 PictureInPictureManager::SetActiveController(pipController);
335 PictureInPictureManager::DoLocateSource();
336 }
337
338 /**
339 * @tc.name: DoRestore
340 * @tc.desc: DoRestore
341 * @tc.type: FUNC
342 */
343 HWTEST_F(PictureInPictureManagerTest, DoRestore, Function | SmallTest | Level2)
344 {
345 auto mw = sptr<MockWindow>::MakeSptr();
346 ASSERT_NE(nullptr, mw);
347 auto option = sptr<PipOption>::MakeSptr();
348 ASSERT_NE(nullptr, option);
349 sptr<PictureInPictureController> pipController =
350 new (std::nothrow) PictureInPictureController(option, nullptr, 100, nullptr);
351 ASSERT_NE(pipController, nullptr);
352 pipController->curState_ = PiPWindowState::STATE_STARTED;
353 PictureInPictureManager::activeController_ = nullptr;
354 PictureInPictureManager::DoRestore();
355 ASSERT_EQ(pipController->curState_, PiPWindowState::STATE_STARTED);
356 pipController->window_ = mw;
357 PictureInPictureManager::SetActiveController(pipController);
358 PictureInPictureManager::DoRestore();
359 ASSERT_EQ(pipController->curState_, PiPWindowState::STATE_STOPPING);
360 }
361
362 /**
363 * @tc.name: DoClose
364 * @tc.desc: DoClose
365 * @tc.type: FUNC
366 */
367 HWTEST_F(PictureInPictureManagerTest, DoClose, Function | SmallTest | Level2)
368 {
369 auto mw = sptr<MockWindow>::MakeSptr();
370 ASSERT_NE(nullptr, mw);
371 auto option = sptr<PipOption>::MakeSptr();
372 ASSERT_NE(nullptr, option);
373 auto pipController = sptr<PictureInPictureController>::MakeSptr(option, nullptr, 100, nullptr);
374 ASSERT_NE(pipController, nullptr);
375 pipController->curState_ = PiPWindowState::STATE_STARTED;
376 PictureInPictureManager::activeController_ = nullptr;
377 ASSERT_EQ(false, PictureInPictureManager::HasActiveController());
378 PictureInPictureManager::SetActiveController(pipController);
379 ASSERT_EQ(true, PictureInPictureManager::HasActiveController());
380 PictureInPictureManager::DoClose(true, true);
381 pipController->window_ = mw;
382 PictureInPictureManager::DoClose(false, true);
383 ASSERT_EQ(false, PictureInPictureManager::HasActiveController());
384 ASSERT_EQ(pipController->curState_, PiPWindowState::STATE_STOPPED);
385 }
386
387 /**
388 * @tc.name: DoActionEvent
389 * @tc.desc: DoActionEvent
390 * @tc.type: FUNC
391 */
392 HWTEST_F(PictureInPictureManagerTest, DoActionEvent, Function | SmallTest | Level2)
393 {
394 auto option = sptr<PipOption>::MakeSptr();
395 ASSERT_NE(nullptr, option);
396 auto pipController = sptr<PictureInPictureController>::MakeSptr(option, nullptr, 100, nullptr);
397 ASSERT_NE(pipController, nullptr);
398 PictureInPictureManager::activeController_ = nullptr;
399 ASSERT_EQ(false, PictureInPictureManager::HasActiveController());
400 std::string actionName = "test";
401 PictureInPictureManager::DoActionEvent(actionName, 0);
402 PictureInPictureManager::SetActiveController(pipController);
403 ASSERT_EQ(true, PictureInPictureManager::HasActiveController());
404 const std::string ACTION_CLOSE = "close";
405 PictureInPictureManager::DoActionEvent(ACTION_CLOSE, 0);
406 }
407
408 /**
409 * @tc.name: AutoStartPipWindow
410 * @tc.desc: AutoStartPipWindow
411 * @tc.type: FUNC
412 */
413 HWTEST_F(PictureInPictureManagerTest, AutoStartPipWindow, Function | SmallTest | Level2)
414 {
415 PictureInPictureManager::autoStartController_ = nullptr;
416 PictureInPictureManager::AutoStartPipWindow();
417
418 sptr<PipOption> option = new (std::nothrow) PipOption();
419 ASSERT_NE(nullptr, option);
420 sptr<PictureInPictureController> pipController =
421 new (std::nothrow) PictureInPictureController(option, nullptr, 100, nullptr);
422 PictureInPictureManager::autoStartController_ = pipController;
423 option->SetTypeNodeEnabled(true);
424 PictureInPictureManager::AutoStartPipWindow();
425 option->SetTypeNodeEnabled(false);
426 PictureInPictureManager::AutoStartPipWindow();
427 SingletonContainer::Get<PiPReporter>().ReportPiPActionEvent(1, "close");
428 }
429
430 /**
431 * @tc.name: DoDestroy
432 * @tc.desc: DoDestroy
433 * @tc.type: FUNC
434 */
435 HWTEST_F(PictureInPictureManagerTest, DoDestroy, Function | SmallTest | Level2)
436 {
437 auto mw = sptr<MockWindow>::MakeSptr();
438 ASSERT_NE(nullptr, mw);
439 auto option = sptr<PipOption>::MakeSptr();
440 ASSERT_NE(nullptr, option);
441 auto pipController = sptr<PictureInPictureController>::MakeSptr(option, nullptr, 100, nullptr);
442 ASSERT_NE(pipController, nullptr);
443 pipController->curState_ = PiPWindowState::STATE_STARTED;
444 PictureInPictureManager::activeController_ = nullptr;
445 ASSERT_FALSE(PictureInPictureManager::HasActiveController());
446 PictureInPictureManager::DoDestroy();
447 ASSERT_EQ(pipController->curState_, PiPWindowState::STATE_STARTED);
448
449 PictureInPictureManager::activeController_ = pipController;
450 ASSERT_TRUE(PictureInPictureManager::HasActiveController());
451 pipController->window_ = mw;
452 PictureInPictureManager::DoDestroy();
453 ASSERT_EQ(pipController->curState_, PiPWindowState::STATE_STOPPED);
454 }
455 } // namespace
456 } // namespace Rosen
457 } // namespace OHOS