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 <gmock/gmock.h>
19 #include "ability_context_impl.h"
20 #include "floating_ball_controller.h"
21 #include "floating_ball_manager.h"
22 #include "modifier_render_thread/rs_modifiers_draw_thread.h"
23 #include "parameters.h"
24 #include "window.h"
25 #include "wm_common.h"
26
27 using namespace testing;
28 using namespace testing::ext;
29
30 namespace OHOS {
31 namespace Rosen {
32
33 class MockWindow : public Window {
34 public:
35 WindowState state_ = WindowState::STATE_INITIAL;
36 const uint32_t mockWindowId_ = 101;
MockWindow()37 MockWindow() {};
~MockWindow()38 ~MockWindow() {};
39 MOCK_METHOD3(Show, WMError(uint32_t reason, bool withAnimation, bool withFocus));
40 MOCK_METHOD1(Destroy, WMError(uint32_t reason));
41 MOCK_METHOD0(NotifyPrepareCloseFloatingBall, void());
42 MOCK_METHOD2(UpdateFloatingBall, WMError(const FloatingBallTemplateBaseInfo& fbTemplateBaseInfo,
43 const std::shared_ptr<Media::PixelMap>& icon));
44 MOCK_METHOD1(RestoreFbMainWindow, WMError(const std::shared_ptr<AAFwk::Want>& want));
45 MOCK_METHOD1(GetFloatingBallWindowId, WMError(uint32_t& windowId));
GetWindowId() const46 uint32_t GetWindowId() const override
47 {
48 return mockWindowId_;
49 }
50
SetWindowState(const WindowState & state)51 void SetWindowState(const WindowState& state)
52 {
53 state_ = state;
54 }
55
GetWindowState() const56 WindowState GetWindowState() const override
57 {
58 return state_;
59 }
60 };
61
62 class MockLifeCycleListener : public IFbLifeCycle {
63 public:
OnFloatingBallStart()64 void OnFloatingBallStart() override
65 {
66 return;
67 }
OnFloatingBallStop()68 void OnFloatingBallStop() override
69 {
70 return;
71 }
72 };
73
74 class MockClickListener : public IFbClickObserver {
75 public:
76
OnClickEvent()77 void OnClickEvent() override
78 {
79 return;
80 }
81 };
82
83 class FloatingBallControllerTest : public testing::Test {
84 public:
85 static void SetUpTestCase();
86 static void TearDownTestCase();
87 void SetUp() override;
88 void TearDown() override;
89
90 sptr<FloatingBallController> fbController_;
91 sptr<FbOption> option_;
92 sptr<MockWindow> mw_;
93 };
94
SetUpTestCase()95 void FloatingBallControllerTest::SetUpTestCase()
96 {
97 }
98
TearDownTestCase()99 void FloatingBallControllerTest::TearDownTestCase()
100 {
101 #ifdef RS_ENABLE_VK
102 RSModifiersDrawThread::Destroy();
103 #endif
104 }
105
SetUp()106 void FloatingBallControllerTest::SetUp()
107 {
108 int32_t windowId = 100;
109 mw_ = sptr<MockWindow>::MakeSptr();
110 ASSERT_NE(nullptr, mw_);
111 fbController_ = sptr<FloatingBallController>::MakeSptr(mw_, windowId, nullptr);
112 ASSERT_NE(nullptr, fbController_);
113 option_ = sptr<FbOption>::MakeSptr();
114 ASSERT_NE(nullptr, option_);
115 }
116
TearDown()117 void FloatingBallControllerTest::TearDown()
118 {
119 fbController_ = nullptr;
120 option_ = nullptr;
121 mw_ = nullptr;
122 }
123
124 namespace {
125 /**
126 * @tc.name: CreateFloatingBallWindow
127 * @tc.desc: CreateFloatingBallWindow
128 * @tc.type: FUNC
129 */
130 HWTEST_F(FloatingBallControllerTest, CreateFloatingBallWindow01, TestSize.Level1)
131 {
132 std::shared_ptr<AbilityRuntime::AbilityContextImpl> contextPtr =
133 std::make_shared<AbilityRuntime::AbilityContextImpl>();
134 fbController_->contextPtr_ = &contextPtr;
135 sptr<FbOption> nullOption = nullptr;
136 EXPECT_EQ(WMError::WM_ERROR_FB_STATE_ABNORMALLY, fbController_->CreateFloatingBallWindow(nullOption));
137 mw_->SetWindowState(WindowState::STATE_INITIAL);
138 EXPECT_EQ(WMError::WM_ERROR_FB_CREATE_FAILED, fbController_->CreateFloatingBallWindow(option_));
139 mw_->SetWindowState(WindowState::STATE_SHOWN);
140 EXPECT_EQ(WMError::WM_ERROR_FB_CREATE_FAILED, fbController_->CreateFloatingBallWindow(option_));
141
142 fbController_->CreateFloatingBallWindow(option_);
143 fbController_->UpdateMainWindow(nullptr);
144 EXPECT_EQ(100, fbController_->mainWindowId_);
145 fbController_->UpdateMainWindow(mw_);
146 EXPECT_EQ(101, fbController_->mainWindowId_);
147 fbController_->contextPtr_ = nullptr;
148 }
149
150 /**
151 * @tc.name: StartFloatingBall
152 * @tc.desc: StartFloatingBall
153 * @tc.type: FUNC
154 */
155 HWTEST_F(FloatingBallControllerTest, StartFloatingBall01, TestSize.Level1)
156 {
157 sptr<FbOption> nullOption = nullptr;
158 EXPECT_EQ(WMError::WM_ERROR_FB_STATE_ABNORMALLY, fbController_->StartFloatingBall(nullOption));
159 fbController_->curState_ = FbWindowState::STATE_STARTING;
160 EXPECT_EQ(WMError::WM_ERROR_FB_REPEAT_OPERATION, fbController_->StartFloatingBall(option_));
161 fbController_->curState_ = FbWindowState::STATE_STARTED;
162 EXPECT_EQ(WMError::WM_ERROR_FB_REPEAT_OPERATION, fbController_->StartFloatingBall(option_));
163
164 fbController_->curState_ = FbWindowState::STATE_UNDEFINED;
165 FloatingBallManager::SetActiveController(fbController_);
166 EXPECT_EQ(WMError::WM_ERROR_FB_STATE_ABNORMALLY, fbController_->StartFloatingBall(option_));
167 FloatingBallManager::RemoveActiveController(fbController_);
168
169 auto activeFbController = sptr<FloatingBallController>::MakeSptr(mw_, 100, nullptr);
170 FloatingBallManager::SetActiveController(activeFbController);
171 EXPECT_EQ(WMError::WM_ERROR_FB_REPEAT_CONTROLLER, fbController_->StartFloatingBall(option_));
172
173 FloatingBallManager::RemoveActiveController(activeFbController);
174 EXPECT_EQ(WMError::WM_ERROR_FB_STATE_ABNORMALLY, fbController_->StartFloatingBall(option_));
175
176 std::unique_ptr<AbilityRuntime::AbilityContextImpl> contextPtr =
177 std::make_unique<AbilityRuntime::AbilityContextImpl>();
178 fbController_->contextPtr_ = contextPtr.get();
179 EXPECT_NE(WMError::WM_OK, fbController_->StartFloatingBall(option_));
180 EXPECT_EQ(FbWindowState::STATE_UNDEFINED, fbController_->GetControllerState());
181 fbController_->contextPtr_ = nullptr;
182 }
183
184 /**
185 * @tc.name: LifeCycleTest
186 * @tc.desc: LifeCycleTest
187 * @tc.type: FUNC
188 */
189 HWTEST_F(FloatingBallControllerTest, LifeCycleTest01, TestSize.Level1)
190 {
191 EXPECT_EQ(WMError::WM_ERROR_FB_INTERNAL_ERROR, fbController_->RegisterFbLifecycle(nullptr));
192 auto lifeListener = sptr<MockLifeCycleListener>::MakeSptr();
193 EXPECT_EQ(WMError::WM_OK, fbController_->RegisterFbLifecycle(lifeListener));
194 // repeat register
195 EXPECT_EQ(WMError::WM_OK, fbController_->RegisterFbLifecycle(lifeListener));
196 fbController_->fbLifeCycleListeners_.emplace_back(nullptr);
197 fbController_->OnFloatingBallStart();
198 fbController_->OnFloatingBallStop();
199 // unregister
200 EXPECT_EQ(WMError::WM_ERROR_FB_INTERNAL_ERROR, fbController_->UnRegisterFbLifecycle(nullptr));
201 EXPECT_EQ(WMError::WM_OK, fbController_->UnRegisterFbLifecycle(lifeListener));
202 fbController_->fbLifeCycleListeners_.clear();
203 }
204
205 /**
206 * @tc.name: ClickTest
207 * @tc.desc: ClickTest
208 * @tc.type: FUNC
209 */
210 HWTEST_F(FloatingBallControllerTest, ClickTest01, TestSize.Level1)
211 {
212 EXPECT_EQ(WMError::WM_ERROR_FB_INTERNAL_ERROR, fbController_->RegisterFbClickObserver(nullptr));
213 auto clickListener = sptr<MockClickListener>::MakeSptr();
214 EXPECT_EQ(WMError::WM_OK, fbController_->RegisterFbClickObserver(clickListener));
215 // repeat register
216 EXPECT_EQ(WMError::WM_OK, fbController_->RegisterFbClickObserver(clickListener));
217 fbController_->fbClickObservers_.emplace_back(nullptr);
218 fbController_->OnFloatingBallClick();
219 // unregister
220 EXPECT_EQ(WMError::WM_ERROR_FB_INTERNAL_ERROR, fbController_->UnRegisterFbClickObserver(nullptr));
221 EXPECT_EQ(WMError::WM_OK, fbController_->UnRegisterFbClickObserver(clickListener));
222 fbController_->fbClickObservers_.clear();
223 }
224
225 /**
226 * @tc.name: UpdateFloatingBall
227 * @tc.desc: UpdateFloatingBall
228 * @tc.type: FUNC
229 */
230 HWTEST_F(FloatingBallControllerTest, UpdateFloatingBall01, TestSize.Level1)
231 {
232 fbController_->curState_ = FbWindowState::STATE_STOPPED;
233 EXPECT_EQ(WMError::WM_ERROR_FB_INVALID_STATE, fbController_->UpdateFloatingBall(option_));
234
235 fbController_->curState_ = FbWindowState::STATE_STARTED;
236 sptr<FbOption> nullOption = nullptr;
237 EXPECT_EQ(WMError::WM_ERROR_FB_STATE_ABNORMALLY, fbController_->UpdateFloatingBall(nullOption));
238 fbController_->window_ = nullptr;
239 EXPECT_EQ(WMError::WM_ERROR_FB_STATE_ABNORMALLY, fbController_->UpdateFloatingBall(option_));
240
241 fbController_->window_ = mw_;
242 fbController_->curState_ = FbWindowState::STATE_STOPPED;
243 EXPECT_EQ(WMError::WM_ERROR_FB_INVALID_STATE, fbController_->UpdateFloatingBall(option_));
244 EXPECT_CALL(*(mw_), UpdateFloatingBall(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
245 fbController_->curState_ = FbWindowState::STATE_STARTED;
246 EXPECT_EQ(WMError::WM_OK, fbController_->UpdateFloatingBall(option_));
247 }
248
249 /**
250 * @tc.name: StopFloatingBall
251 * @tc.desc: StopFloatingBall
252 * @tc.type: FUNC
253 */
254 HWTEST_F(FloatingBallControllerTest, StopFloatingBall01, TestSize.Level1)
255 {
256 fbController_->curState_ = FbWindowState::STATE_STOPPED;
257 EXPECT_EQ(WMError::WM_ERROR_FB_REPEAT_OPERATION, fbController_->StopFloatingBallFromClient());
258 fbController_->curState_ = FbWindowState::STATE_STOPPING;
259 EXPECT_EQ(WMError::WM_ERROR_FB_REPEAT_OPERATION, fbController_->StopFloatingBallFromClient());
260 fbController_->curState_ = FbWindowState::STATE_STARTED;
261 EXPECT_CALL(*(mw_), NotifyPrepareCloseFloatingBall()).Times(1);
262 fbController_->window_ = mw_;
263 EXPECT_EQ(WMError::WM_OK, fbController_->StopFloatingBallFromClient());
264 fbController_->window_ = nullptr;
265 fbController_->curState_ = FbWindowState::STATE_STARTED;
266 EXPECT_EQ(WMError::WM_ERROR_FB_STATE_ABNORMALLY, fbController_->StopFloatingBallFromClient());
267 }
268
269 /**
270 * @tc.name: StopFloatingBall
271 * @tc.desc: StopFloatingBall
272 * @tc.type: FUNC
273 */
274 HWTEST_F(FloatingBallControllerTest, StopFloatingBall02, TestSize.Level1)
275 {
276 fbController_->stopFromClient_ = false;
277 fbController_->curState_ = FbWindowState::STATE_STOPPING;
278 EXPECT_EQ(WMError::WM_ERROR_FB_REPEAT_OPERATION, fbController_->StopFloatingBall());
279 fbController_->curState_ = FbWindowState::STATE_STOPPED;
280 EXPECT_EQ(WMError::WM_ERROR_FB_REPEAT_OPERATION, fbController_->StopFloatingBall());
281
282 fbController_->curState_ = FbWindowState::STATE_STARTED;
283 EXPECT_CALL(*(mw_), Destroy(_)).Times(1);
284 fbController_->window_ = mw_;
285 EXPECT_EQ(WMError::WM_OK, fbController_->StopFloatingBall());
286 EXPECT_EQ(FbWindowState::STATE_STOPPED, fbController_->GetControllerState());
287
288 fbController_->window_ = nullptr;
289 fbController_->curState_ = FbWindowState::STATE_STARTED;
290 EXPECT_EQ(WMError::WM_ERROR_FB_STATE_ABNORMALLY, fbController_->StopFloatingBall());
291 EXPECT_EQ(WMError::WM_ERROR_FB_INTERNAL_ERROR, fbController_->DestroyFloatingBallWindow());
292 EXPECT_EQ(nullptr, fbController_->GetFbWindow());
293 }
294
295 /**
296 * @tc.name: RestoreFloatingBallAbility
297 * @tc.desc: RestoreFloatingBallAbility
298 * @tc.type: FUNC
299 */
300 HWTEST_F(FloatingBallControllerTest, RestoreFloatingBallAbility, TestSize.Level1)
301 {
302 std::shared_ptr<AAFwk::Want> want = std::make_shared<AAFwk::Want>();
303 fbController_->curState_ = FbWindowState::STATE_STARTED;
304 EXPECT_EQ(WMError::WM_ERROR_FB_STATE_ABNORMALLY, fbController_->RestoreMainWindow(want));
305 fbController_->window_ = mw_;
306 fbController_->curState_ = FbWindowState::STATE_STOPPING;
307 EXPECT_EQ(WMError::WM_ERROR_FB_INVALID_STATE, fbController_->RestoreMainWindow(want));
308 fbController_->curState_ = FbWindowState::STATE_STARTED;
309 EXPECT_CALL(*(mw_), RestoreFbMainWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
310 EXPECT_EQ(WMError::WM_OK, fbController_->RestoreMainWindow(want));
311 }
312
313 /**
314 * @tc.name: GetFloatingBallInfo
315 * @tc.desc: GetFloatingBallInfo
316 * @tc.type: FUNC
317 */
318 HWTEST_F(FloatingBallControllerTest, GetFloatingBallInfo, TestSize.Level1)
319 {
320 EXPECT_CALL(*(mw_), GetFloatingBallWindowId(_)).Times(1).WillOnce(Return(WMError::WM_OK));
321 fbController_->window_ = mw_;
322 uint32_t mockId = 1;
323 EXPECT_EQ(WMError::WM_ERROR_FB_INVALID_STATE, fbController_->GetFloatingBallWindowInfo(mockId));
324 fbController_->curState_ = FbWindowState::STATE_STARTED;
325 fbController_->window_ = nullptr;
326 EXPECT_EQ(WMError::WM_ERROR_FB_STATE_ABNORMALLY, fbController_->GetFloatingBallWindowInfo(mockId));
327 fbController_->window_ = mw_;
328 EXPECT_EQ(WMError::WM_OK, fbController_->GetFloatingBallWindowInfo(mockId));
329 }
330 }
331 }
332 }