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, TestSize.Level1)
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, TestSize.Level1)
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, TestSize.Level1)
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, TestSize.Level1)
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, TestSize.Level1)
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<PictureInPictureControllerBase> 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, TestSize.Level1)
166 {
167 sptr<PipOption> option = new (std::nothrow) PipOption();
168 ASSERT_NE(nullptr, option);
169 sptr<PictureInPictureControllerBase> 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, TestSize.Level1)
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, TestSize.Level1)
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, TestSize.Level1)
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, TestSize.Level1)
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, TestSize.Level1)
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 PictureInPictureManager::SetActiveController(pipController);
292 PictureInPictureManager::DoPreRestore();
293 ASSERT_EQ(pipController->curState_, PiPWindowState::STATE_RESTORING);
294 }
295
296 /**
297 * @tc.name: DoPrepareSource
298 * @tc.desc: DoPrepareSource
299 * @tc.type: FUNC
300 */
301 HWTEST_F(PictureInPictureManagerTest, DoPrepareSource, TestSize.Level1)
302 {
303 auto mw = sptr<MockWindow>::MakeSptr();
304 ASSERT_NE(nullptr, mw);
305 auto option = sptr<PipOption>::MakeSptr();
306 ASSERT_NE(nullptr, option);
307 auto pipController = sptr<PictureInPictureController>::MakeSptr(option, nullptr, 100, nullptr);
308 ASSERT_NE(pipController, nullptr);
309 PictureInPictureManager::activeController_ = nullptr;
310 PictureInPictureManager::DoPrepareSource();
311 PictureInPictureManager::SetActiveController(pipController);
312 PictureInPictureManager::DoPrepareSource();
313 }
314
315 /**
316 * @tc.name: DoLocateSource
317 * @tc.desc: DoLocateSource
318 * @tc.type: FUNC
319 */
320 HWTEST_F(PictureInPictureManagerTest, DoLocateSource, TestSize.Level1)
321 {
322 auto mw = sptr<MockWindow>::MakeSptr();
323 ASSERT_NE(nullptr, mw);
324 auto option = sptr<PipOption>::MakeSptr();
325 ASSERT_NE(nullptr, option);
326 auto pipController = sptr<PictureInPictureController>::MakeSptr(option, nullptr, 100, nullptr);
327 ASSERT_NE(pipController, nullptr);
328 PictureInPictureManager::activeController_ = nullptr;
329 PictureInPictureManager::DoLocateSource();
330 PictureInPictureManager::SetActiveController(pipController);
331 PictureInPictureManager::DoLocateSource();
332 }
333
334 /**
335 * @tc.name: DoRestore
336 * @tc.desc: DoRestore
337 * @tc.type: FUNC
338 */
339 HWTEST_F(PictureInPictureManagerTest, DoRestore, TestSize.Level1)
340 {
341 auto mw = sptr<MockWindow>::MakeSptr();
342 ASSERT_NE(nullptr, mw);
343 auto option = sptr<PipOption>::MakeSptr();
344 ASSERT_NE(nullptr, option);
345 sptr<PictureInPictureController> pipController =
346 new (std::nothrow) PictureInPictureController(option, nullptr, 100, nullptr);
347 ASSERT_NE(pipController, nullptr);
348 pipController->curState_ = PiPWindowState::STATE_STARTED;
349 PictureInPictureManager::activeController_ = nullptr;
350 PictureInPictureManager::DoRestore();
351 ASSERT_EQ(pipController->curState_, PiPWindowState::STATE_STARTED);
352 pipController->window_ = mw;
353 PictureInPictureManager::SetActiveController(pipController);
354 PictureInPictureManager::DoRestore();
355 ASSERT_EQ(pipController->curState_, PiPWindowState::STATE_STOPPING);
356 }
357
358 /**
359 * @tc.name: DoClose
360 * @tc.desc: DoClose
361 * @tc.type: FUNC
362 */
363 HWTEST_F(PictureInPictureManagerTest, DoClose, TestSize.Level1)
364 {
365 auto mw = sptr<MockWindow>::MakeSptr();
366 ASSERT_NE(nullptr, mw);
367 auto option = sptr<PipOption>::MakeSptr();
368 ASSERT_NE(nullptr, option);
369 auto pipController = sptr<PictureInPictureController>::MakeSptr(option, nullptr, 100, nullptr);
370 ASSERT_NE(pipController, nullptr);
371 pipController->curState_ = PiPWindowState::STATE_STARTED;
372 PictureInPictureManager::activeController_ = nullptr;
373 ASSERT_EQ(false, PictureInPictureManager::HasActiveController());
374 PictureInPictureManager::SetActiveController(pipController);
375 ASSERT_EQ(true, PictureInPictureManager::HasActiveController());
376 PictureInPictureManager::DoClose(true, true);
377 pipController->window_ = mw;
378 PictureInPictureManager::DoClose(false, true);
379 ASSERT_EQ(false, PictureInPictureManager::HasActiveController());
380 ASSERT_EQ(pipController->curState_, PiPWindowState::STATE_STOPPED);
381 }
382
383 /**
384 * @tc.name: DoActionEvent
385 * @tc.desc: DoActionEvent
386 * @tc.type: FUNC
387 */
388 HWTEST_F(PictureInPictureManagerTest, DoActionEvent, TestSize.Level1)
389 {
390 auto option = sptr<PipOption>::MakeSptr();
391 ASSERT_NE(nullptr, option);
392 auto pipController = sptr<PictureInPictureController>::MakeSptr(option, nullptr, 100, nullptr);
393 ASSERT_NE(pipController, nullptr);
394 PictureInPictureManager::activeController_ = nullptr;
395 ASSERT_EQ(false, PictureInPictureManager::HasActiveController());
396 std::string actionName = "test";
397 PictureInPictureManager::DoActionEvent(actionName, 0);
398 PictureInPictureManager::SetActiveController(pipController);
399 ASSERT_EQ(true, PictureInPictureManager::HasActiveController());
400 const std::string ACTION_CLOSE = "close";
401 PictureInPictureManager::DoActionEvent(ACTION_CLOSE, 0);
402 }
403
404 /**
405 * @tc.name: AutoStartPipWindow
406 * @tc.desc: AutoStartPipWindow
407 * @tc.type: FUNC
408 */
409 HWTEST_F(PictureInPictureManagerTest, AutoStartPipWindow, TestSize.Level1)
410 {
411 PictureInPictureManager::autoStartController_ = nullptr;
412 PictureInPictureManager::AutoStartPipWindow();
413
414 sptr<PipOption> option = new (std::nothrow) PipOption();
415 ASSERT_NE(nullptr, option);
416 sptr<PictureInPictureController> pipController =
417 new (std::nothrow) PictureInPictureController(option, nullptr, 100, nullptr);
418 PictureInPictureManager::autoStartController_ = pipController;
419 option->SetTypeNodeEnabled(true);
420 PictureInPictureManager::AutoStartPipWindow();
421 option->SetTypeNodeEnabled(false);
422 PictureInPictureManager::AutoStartPipWindow();
423 SingletonContainer::Get<PiPReporter>().ReportPiPActionEvent(1, "close");
424 }
425
426 /**
427 * @tc.name: DoDestroy
428 * @tc.desc: DoDestroy
429 * @tc.type: FUNC
430 */
431 HWTEST_F(PictureInPictureManagerTest, DoDestroy, TestSize.Level1)
432 {
433 auto mw = sptr<MockWindow>::MakeSptr();
434 ASSERT_NE(nullptr, mw);
435 auto option = sptr<PipOption>::MakeSptr();
436 ASSERT_NE(nullptr, option);
437 auto pipController = sptr<PictureInPictureController>::MakeSptr(option, nullptr, 100, nullptr);
438 ASSERT_NE(pipController, nullptr);
439
440 PictureInPictureManager::activeController_ = pipController;
441 pipController->window_ = mw;
442 PictureInPictureManager::DoDestroy();
443 ASSERT_EQ(pipController->curState_, PiPWindowState::STATE_STOPPED);
444 }
445 } // namespace
446 } // namespace Rosen
447 } // namespace OHOS