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 {
44 }
45 
TearDownTestCase()46 void PictureInPictureManagerTest::TearDownTestCase()
47 {
48 }
49 
SetUp()50 void PictureInPictureManagerTest::SetUp()
51 {
52 }
53 
TearDown()54 void PictureInPictureManagerTest::TearDown()
55 {
56 }
57 
58 namespace {
59 
60 /**
61  * @tc.name: IsSupportPiP
62  * @tc.desc: IsSupportPiP
63  * @tc.type: FUNC
64  */
65 HWTEST_F(PictureInPictureManagerTest, IsSupportPiP, Function | SmallTest | Level2)
66 {
67     if (SceneBoardJudgement::IsSceneBoardEnabled()) {
68         ASSERT_EQ(true, PictureInPictureManager::IsSupportPiP());
69     } else {
70         ASSERT_EQ(false, PictureInPictureManager::IsSupportPiP());
71     }
72 }
73 
74 /**
75  * @tc.name: PiPWindowState
76  * @tc.desc: PutPipControllerInfo/RemovePipControllerInfo/ReportPiPStartWindow/ReportPiPStopWindow/ReportPiPActionEvent
77  * @tc.type: FUNC
78  */
79 HWTEST_F(PictureInPictureManagerTest, PipControllerInfo, Function | SmallTest | Level2)
80 {
81     sptr<PipOption> option = new PipOption();
82     sptr<PictureInPictureController> pipController = new PictureInPictureController(option, nullptr, 100, nullptr);
83     PictureInPictureManager::PutPipControllerInfo(100, pipController);
84     ASSERT_EQ(1, static_cast<int>(PictureInPictureManager::windowToControllerMap_.size()));
85     PictureInPictureManager::RemovePipControllerInfo(100);
86     ASSERT_EQ(0, static_cast<int>(PictureInPictureManager::windowToControllerMap_.size()));
87     int32_t source = 0;
88     std::string errorReason = "";
89     SingletonContainer::Get<PiPReporter>().ReportPiPStartWindow(source, 1, 1, errorReason);
90     SingletonContainer::Get<PiPReporter>().ReportPiPStopWindow(source, 1, 1, errorReason);
91     source = 1;
92     SingletonContainer::Get<PiPReporter>().ReportPiPStartWindow(source, 1, 1, errorReason);
93     SingletonContainer::Get<PiPReporter>().ReportPiPStopWindow(source, 1, 1, errorReason);
94     std::string actionEvent = "";
95     SingletonContainer::Get<PiPReporter>().ReportPiPActionEvent(1, actionEvent);
96     actionEvent = "nextVideo";
97     SingletonContainer::Get<PiPReporter>().ReportPiPActionEvent(1, actionEvent);
98 }
99 
100 /**
101  * @tc.name: PictureInPictureController
102  * @tc.desc: SetActiveController/IsActiveController/HasActiveController/RemoveActiveController
103  * @tc.type: FUNC
104  */
105 HWTEST_F(PictureInPictureManagerTest, PictureInPictureController, Function | SmallTest | Level2)
106 {
107     sptr<PipOption> option = new PipOption();
108     sptr<PictureInPictureController> pipController =
109         new PictureInPictureController(option, nullptr, 100, nullptr);
110     PictureInPictureManager::activeController_ = nullptr;
111     ASSERT_FALSE(PictureInPictureManager::HasActiveController());
112     PictureInPictureManager::RemoveActiveController(pipController);
113     ASSERT_FALSE(PictureInPictureManager::HasActiveController());
114     ASSERT_FALSE(PictureInPictureManager::IsActiveController(pipController));
115 
116     PictureInPictureManager::SetActiveController(pipController);
117     ASSERT_TRUE(PictureInPictureManager::HasActiveController());
118     ASSERT_TRUE(PictureInPictureManager::IsActiveController(pipController));
119     ASSERT_TRUE(PictureInPictureManager::IsAttachedToSameWindow(100));
120     ASSERT_FALSE(PictureInPictureManager::IsAttachedToSameWindow(1));
121     PictureInPictureManager::RemoveActiveController(pipController);
122     ASSERT_FALSE(PictureInPictureManager::HasActiveController());
123     ASSERT_FALSE(PictureInPictureManager::IsActiveController(pipController));
124 }
125 
126 /**
127  * @tc.name: ShouldAbortPipStart
128  * @tc.desc: ShouldAbortPipStart
129  * @tc.type: FUNC
130  */
131 HWTEST_F(PictureInPictureManagerTest, ShouldAbortPipStart, Function | SmallTest | Level2)
132 {
133     ASSERT_FALSE(PictureInPictureManager::ShouldAbortPipStart());
134 
135     sptr<PipOption> option = new (std::nothrow) PipOption();
136     ASSERT_NE(nullptr, option);
137     sptr<PictureInPictureController> pipController =
138         new (std::nothrow) PictureInPictureController(option, nullptr, 100, nullptr);
139     ASSERT_NE(pipController, nullptr);
140     PictureInPictureManager::SetActiveController(pipController);
141     pipController->curState_ = PiPWindowState::STATE_STARTING;
142 
143     ASSERT_TRUE(PictureInPictureManager::ShouldAbortPipStart());
144 }
145 
146 /**
147  * @tc.name: GetPipControllerInfo
148  * @tc.desc: GetPipControllerInfo
149  * @tc.type: FUNC
150  */
151 HWTEST_F(PictureInPictureManagerTest, GetPipControllerInfo, Function | SmallTest | Level2)
152 {
153     sptr<PipOption> option = new (std::nothrow) PipOption();
154     ASSERT_NE(nullptr, option);
155     sptr<PictureInPictureController> pipController =
156         new (std::nothrow) PictureInPictureController(option, nullptr, 100, nullptr);
157     ASSERT_NE(pipController, nullptr);
158     PictureInPictureManager::SetActiveController(pipController);
159     int32_t windowId = 1;
160     ASSERT_EQ(nullptr, PictureInPictureManager::GetPipControllerInfo(windowId));
161 
162     sptr<PictureInPictureController> pipController1 =
163         new (std::nothrow) PictureInPictureController(option, nullptr, 100, nullptr);
164     ASSERT_NE(pipController1, nullptr);
165     PictureInPictureManager::windowToControllerMap_.insert(std::make_pair(windowId, pipController1));
166     ASSERT_EQ(pipController1, PictureInPictureManager::GetPipControllerInfo(windowId));
167 }
168 
169 /**
170  * @tc.name: AttachAutoStartController
171  * @tc.desc: AttachAutoStartController
172  * @tc.type: FUNC
173  */
174 HWTEST_F(PictureInPictureManagerTest, AttachAutoStartController, Function | SmallTest | Level2)
175 {
176     PictureInPictureManager::AttachAutoStartController(0, nullptr);
177     sptr<PipOption> option = new (std::nothrow) PipOption();
178     ASSERT_NE(nullptr, option);
179     sptr<PictureInPictureController> pipController =
180         new (std::nothrow) PictureInPictureController(option, nullptr, 100, nullptr);
181     ASSERT_NE(pipController, nullptr);
182     PictureInPictureManager::SetActiveController(pipController);
183     wptr<PictureInPictureController> pipController1 =
184         new (std::nothrow) PictureInPictureController(option, nullptr, 100, nullptr);
185     ASSERT_NE(pipController1, nullptr);
186     PictureInPictureManager::AttachAutoStartController(1, pipController1);
187     ASSERT_EQ(pipController1, PictureInPictureManager::autoStartControllerMap_[1]);
188 }
189 
190 /**
191  * @tc.name: DetachAutoStartController
192  * @tc.desc: DetachAutoStartController
193  * @tc.type: FUNC
194  */
195 HWTEST_F(PictureInPictureManagerTest, DetachAutoStartController, Function | SmallTest | Level2)
196 {
197     sptr<PipOption> option = new (std::nothrow) PipOption();
198     ASSERT_NE(nullptr, option);
199     wptr<PictureInPictureController> pipController =
200         new (std::nothrow) PictureInPictureController(option, nullptr, 100, nullptr);
201     ASSERT_NE(pipController, nullptr);
202     wptr<PictureInPictureController> pipController1 =
203         new (std::nothrow) PictureInPictureController(option, nullptr, 100, nullptr);
204     ASSERT_NE(pipController1, nullptr);
205     PictureInPictureManager::AttachAutoStartController(0, pipController);
206     PictureInPictureManager::AttachAutoStartController(1, pipController1);
207     ASSERT_EQ(2, PictureInPictureManager::autoStartControllerMap_.size());
208     PictureInPictureManager::DetachAutoStartController(0, nullptr);
209     ASSERT_EQ(1, PictureInPictureManager::autoStartControllerMap_.size());
210     PictureInPictureManager::DetachAutoStartController(0, pipController);
211     ASSERT_EQ(1, PictureInPictureManager::autoStartControllerMap_.size());
212 }
213 
214 /**
215  * @tc.name: IsAttachedToSameWindow
216  * @tc.desc: IsAttachedToSameWindow
217  * @tc.type: FUNC
218  */
219 HWTEST_F(PictureInPictureManagerTest, IsAttachedToSameWindow, Function | SmallTest | Level2)
220 {
221     bool res = PictureInPictureManager::IsAttachedToSameWindow(0);
222     ASSERT_EQ(res, false);
223 
224     sptr<PipOption> option = new (std::nothrow) PipOption();
225     ASSERT_NE(nullptr, option);
226     sptr<PictureInPictureController> pipController =
227         new (std::nothrow) PictureInPictureController(option, nullptr, 100, nullptr);
228     ASSERT_NE(pipController, nullptr);
229 
230     PictureInPictureManager::activeController_ = nullptr;
231     ASSERT_FALSE(PictureInPictureManager::HasActiveController());
232     bool res1 = PictureInPictureManager::IsAttachedToSameWindow(1);
233     ASSERT_EQ(res1, false);
234 
235     PictureInPictureManager::SetActiveController(pipController);
236     bool res2 = PictureInPictureManager::IsAttachedToSameWindow(100);
237     ASSERT_EQ(res2, true);
238     bool res3 = PictureInPictureManager::IsAttachedToSameWindow(1);
239     ASSERT_EQ(res3, false);
240 }
241 
242 /**
243  * @tc.name: GetCurrentWindow
244  * @tc.desc: GetCurrentWindow
245  * @tc.type: FUNC
246  */
247 HWTEST_F(PictureInPictureManagerTest, GetCurrentWindow, Function | SmallTest | Level2)
248 {
249     ASSERT_EQ(nullptr, PictureInPictureManager::GetCurrentWindow());
250 
251     sptr<PipOption> option = new (std::nothrow) PipOption();
252     ASSERT_NE(nullptr, option);
253     sptr<PictureInPictureController> pipController =
254         new (std::nothrow) PictureInPictureController(option, nullptr, 100, nullptr);
255     ASSERT_NE(pipController, nullptr);
256 
257     PictureInPictureManager::activeController_ = nullptr;
258     ASSERT_FALSE(PictureInPictureManager::HasActiveController());
259     ASSERT_EQ(nullptr, PictureInPictureManager::GetCurrentWindow());
260 
261     sptr<Window> window = nullptr;
262     ASSERT_EQ(window, pipController->window_);
263     PictureInPictureManager::SetActiveController(pipController);
264     window = PictureInPictureManager::GetCurrentWindow();
265     ASSERT_EQ(window, pipController->window_);
266 }
267 
268 /**
269  * @tc.name: DoPreRestore
270  * @tc.desc: DoPreRestore
271  * @tc.type: FUNC
272  */
273 HWTEST_F(PictureInPictureManagerTest, DoPreRestore, Function | SmallTest | Level2)
274 {
275     auto mw = sptr<MockWindow>::MakeSptr();
276     ASSERT_NE(nullptr, mw);
277     auto option = sptr<PipOption>::MakeSptr();
278     ASSERT_NE(nullptr, option);
279     auto pipController = sptr<PictureInPictureController>::MakeSptr(option, nullptr, 100, nullptr);
280     ASSERT_NE(pipController, nullptr);
281     pipController->curState_ = PiPWindowState::STATE_STARTED;
282     PictureInPictureManager::activeController_ = nullptr;
283     PictureInPictureManager::DoPreRestore();
284     ASSERT_EQ(pipController->curState_, PiPWindowState::STATE_STARTED);
285     PictureInPictureManager::SetActiveController(pipController);
286     PictureInPictureManager::DoPreRestore();
287     ASSERT_EQ(pipController->curState_, PiPWindowState::STATE_RESTORING);
288 }
289 
290 /**
291  * @tc.name: DoPrepareSource
292  * @tc.desc: DoPrepareSource
293  * @tc.type: FUNC
294  */
295 HWTEST_F(PictureInPictureManagerTest, DoPrepareSource, Function | SmallTest | Level2)
296 {
297     auto mw = sptr<MockWindow>::MakeSptr();
298     ASSERT_NE(nullptr, mw);
299     auto option = sptr<PipOption>::MakeSptr();
300     ASSERT_NE(nullptr, option);
301     auto pipController = sptr<PictureInPictureController>::MakeSptr(option, nullptr, 100, nullptr);
302     ASSERT_NE(pipController, nullptr);
303     PictureInPictureManager::activeController_ = nullptr;
304     PictureInPictureManager::DoPreRestore();
305     PictureInPictureManager::SetActiveController(pipController);
306     PictureInPictureManager::DoPreRestore();
307 }
308 
309 /**
310  * @tc.name: DoRestore
311  * @tc.desc: DoRestore
312  * @tc.type: FUNC
313  */
314 HWTEST_F(PictureInPictureManagerTest, DoRestore, Function | SmallTest | Level2)
315 {
316     auto mw = sptr<MockWindow>::MakeSptr();
317     ASSERT_NE(nullptr, mw);
318     auto option = sptr<PipOption>::MakeSptr();
319     ASSERT_NE(nullptr, option);
320     sptr<PictureInPictureController> pipController =
321         new (std::nothrow) PictureInPictureController(option, nullptr, 100, nullptr);
322     ASSERT_NE(pipController, nullptr);
323     pipController->curState_ = PiPWindowState::STATE_STARTED;
324     PictureInPictureManager::activeController_ = nullptr;
325     PictureInPictureManager::DoRestore();
326     ASSERT_EQ(pipController->curState_, PiPWindowState::STATE_STARTED);
327     pipController->window_ = mw;
328     PictureInPictureManager::SetActiveController(pipController);
329     PictureInPictureManager::DoRestore();
330     ASSERT_EQ(pipController->curState_, PiPWindowState::STATE_STOPPING);
331 }
332 
333 /**
334  * @tc.name: DoClose
335  * @tc.desc: DoClose
336  * @tc.type: FUNC
337  */
338 HWTEST_F(PictureInPictureManagerTest, DoClose, Function | SmallTest | Level2)
339 {
340     auto mw = sptr<MockWindow>::MakeSptr();
341     ASSERT_NE(nullptr, mw);
342     auto option = sptr<PipOption>::MakeSptr();
343     ASSERT_NE(nullptr, option);
344     auto pipController = sptr<PictureInPictureController>::MakeSptr(option, nullptr, 100, nullptr);
345     ASSERT_NE(pipController, nullptr);
346     pipController->curState_ = PiPWindowState::STATE_STARTED;
347     PictureInPictureManager::activeController_ = nullptr;
348     ASSERT_EQ(false, PictureInPictureManager::HasActiveController());
349     PictureInPictureManager::SetActiveController(pipController);
350     ASSERT_EQ(true, PictureInPictureManager::HasActiveController());
351     PictureInPictureManager::DoClose(true, true);
352     pipController->window_ = mw;
353     PictureInPictureManager::DoClose(false, true);
354     ASSERT_EQ(false, PictureInPictureManager::HasActiveController());
355     ASSERT_EQ(pipController->curState_, PiPWindowState::STATE_STOPPED);
356 }
357 
358 /**
359  * @tc.name: DoActionEvent
360  * @tc.desc: DoActionEvent
361  * @tc.type: FUNC
362  */
363 HWTEST_F(PictureInPictureManagerTest, DoActionEvent, Function | SmallTest | Level2)
364 {
365     auto option = sptr<PipOption>::MakeSptr();
366     ASSERT_NE(nullptr, option);
367     auto pipController = sptr<PictureInPictureController>::MakeSptr(option, nullptr, 100, nullptr);
368     ASSERT_NE(pipController, nullptr);
369     PictureInPictureManager::activeController_ = nullptr;
370     ASSERT_EQ(false, PictureInPictureManager::HasActiveController());
371     std::string actionName = "test";
372     PictureInPictureManager::DoActionEvent(actionName, 0);
373     PictureInPictureManager::SetActiveController(pipController);
374     ASSERT_EQ(true, PictureInPictureManager::HasActiveController());
375     const std::string ACTION_CLOSE = "close";
376     PictureInPictureManager::DoActionEvent(ACTION_CLOSE, 0);
377 }
378 
379 /**
380  * @tc.name: AutoStartPipWindow
381  * @tc.desc: AutoStartPipWindow
382  * @tc.type: FUNC
383  */
384 HWTEST_F(PictureInPictureManagerTest, AutoStartPipWindow, Function | SmallTest | Level2)
385 {
386     PictureInPictureManager::autoStartController_ = nullptr;
387     PictureInPictureManager::AutoStartPipWindow();
388 
389     sptr<PipOption> option = new (std::nothrow) PipOption();
390     ASSERT_NE(nullptr, option);
391     sptr<PictureInPictureController> pipController =
392         new (std::nothrow) PictureInPictureController(option, nullptr, 100, nullptr);
393     PictureInPictureManager::autoStartController_ = pipController;
394     option->SetTypeNodeEnabled(true);
395     PictureInPictureManager::AutoStartPipWindow();
396     option->SetTypeNodeEnabled(false);
397     PictureInPictureManager::AutoStartPipWindow();
398     SingletonContainer::Get<PiPReporter>().ReportPiPActionEvent(1, "close");
399 }
400 
401 /**
402  * @tc.name: DoDestroy
403  * @tc.desc: DoDestroy
404  * @tc.type: FUNC
405  */
406 HWTEST_F(PictureInPictureManagerTest, DoDestroy, Function | SmallTest | Level2)
407 {
408     auto mw = sptr<MockWindow>::MakeSptr();
409     ASSERT_NE(nullptr, mw);
410     auto option = sptr<PipOption>::MakeSptr();
411     ASSERT_NE(nullptr, option);
412     auto pipController = sptr<PictureInPictureController>::MakeSptr(option, nullptr, 100, nullptr);
413     ASSERT_NE(pipController, nullptr);
414     pipController->curState_ = PiPWindowState::STATE_STARTED;
415     PictureInPictureManager::activeController_ = nullptr;
416     ASSERT_FALSE(PictureInPictureManager::HasActiveController());
417     PictureInPictureManager::DoDestroy();
418     ASSERT_EQ(pipController->curState_, PiPWindowState::STATE_STARTED);
419 
420     PictureInPictureManager::activeController_ = pipController;
421     ASSERT_TRUE(PictureInPictureManager::HasActiveController());
422     pipController->window_ = mw;
423     PictureInPictureManager::DoDestroy();
424     ASSERT_EQ(pipController->curState_, PiPWindowState::STATE_STOPPED);
425 }
426 }
427 }
428 }