1 /*
2 * Copyright (c) 2025 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 "application_context.h"
19 #include "input_event.h"
20 #include "key_event.h"
21 #include "mock/mock_session_stage.h"
22 #include "modifier_render_thread/rs_modifiers_draw_thread.h"
23 #include "pointer_event.h"
24
25 #include "screen_session_manager_client/include/screen_session_manager_client.h"
26 #include "session/host/include/main_session.h"
27 #include "session/host/include/keyboard_session.h"
28 #define PRIVATE public
29 #define PROTECTED public
30 #include "session/host/include/scene_session.h"
31 #undef PRIVATE
32 #undef PROTECTED
33 #include "session/host/include/sub_session.h"
34 #include "session/host/include/system_session.h"
35 #include "ui/rs_surface_node.h"
36 #include "window_helper.h"
37 #include "wm_common.h"
38
39 using namespace testing;
40 using namespace testing::ext;
41 namespace OHOS {
42 namespace Rosen {
43 class SceneSessionAnimationTest : public testing::Test {
44 public:
45 SceneSessionAnimationTest();
46 static void SetUpTestCase();
47 static void TearDownTestCase();
48 void SetUp() override;
49 void TearDown() override;
50
51 private:
52 sptr<ScreenSession> defaultScreenSession_;
53 ScreenSessionManagerClient& ssmClient_;
54 };
55
SceneSessionAnimationTest()56 SceneSessionAnimationTest::SceneSessionAnimationTest() : ssmClient_(ScreenSessionManagerClient::GetInstance())
57 {
58 constexpr ScreenId defaultScreenId = 1001;
59 auto screenProperty = ScreenProperty();
60 defaultScreenSession_ = sptr<ScreenSession>::MakeSptr(defaultScreenId, screenProperty, defaultScreenId);
61 {
62 std::lock_guard<std::mutex> lock(ssmClient_.screenSessionMapMutex_);
63 ssmClient_.screenSessionMap_[defaultScreenId] = defaultScreenSession_;
64 }
65 }
66
SetUpTestCase()67 void SceneSessionAnimationTest::SetUpTestCase() {}
68
TearDownTestCase()69 void SceneSessionAnimationTest::TearDownTestCase()
70 {
71 #ifdef RS_ENABLE_VK
72 RSModifiersDrawThread::Destroy();
73 #endif
74 }
75
SetUp()76 void SceneSessionAnimationTest::SetUp() {}
77
TearDown()78 void SceneSessionAnimationTest::TearDown() {}
79
80 namespace {
81 /**
82 * @tc.name: SetWindowCornerRadiusCallback
83 * @tc.desc: SetWindowCornerRadiusCallback
84 * @tc.type: FUNC
85 */
86 HWTEST_F(SceneSessionAnimationTest, SetWindowCornerRadiusCallback, TestSize.Level1)
87 {
88 SessionInfo info;
89 info.abilityName_ = "SetWindowCornerRadiusCallback";
90 info.bundleName_ = "SetWindowCornerRadiusCallback";
91 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
92
__anon5d4b48fa0202(float cornerRadius) 93 NotifySetWindowCornerRadiusFunc func1 = [](float cornerRadius) { return; };
94 sceneSession->SetWindowCornerRadiusCallback(std::move(func1));
95 ASSERT_NE(nullptr, sceneSession->onSetWindowCornerRadiusFunc_);
96 ASSERT_NE(nullptr, sceneSession->property_);
97 EXPECT_EQ(WINDOW_CORNER_RADIUS_INVALID, sceneSession->property_->GetWindowCornerRadius());
98 }
99
100 /**
101 * @tc.name: SetWindowCornerRadiusCallback01
102 * @tc.desc: SetWindowCornerRadiusCallback
103 * @tc.type: FUNC
104 */
105 HWTEST_F(SceneSessionAnimationTest, SetWindowCornerRadiusCallback01, TestSize.Level1)
106 {
107 SessionInfo info;
108 info.abilityName_ = "SetWindowCornerRadiusCallback01";
109 info.bundleName_ = "SetWindowCornerRadiusCallback01";
110 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
111
__anon5d4b48fa0302(float cornerRadius) 112 NotifySetWindowCornerRadiusFunc func1 = [](float cornerRadius) { return; };
113 ASSERT_NE(nullptr, sceneSession->property_);
114 sceneSession->property_->SetWindowCornerRadius(1); // 1 is valid window corner radius
115 sceneSession->SetWindowCornerRadiusCallback(std::move(func1));
116 ASSERT_NE(nullptr, sceneSession->onSetWindowCornerRadiusFunc_);
117 EXPECT_EQ(1, sceneSession->property_->GetWindowCornerRadius()); // 1 is valid window corner radius
118 }
119
120 /**
121 * @tc.name: OnSetWindowCornerRadius
122 * @tc.desc: OnSetWindowCornerRadius
123 * @tc.type: FUNC
124 */
125 HWTEST_F(SceneSessionAnimationTest, SetWindowCornerRadius, TestSize.Level1)
126 {
127 SessionInfo info;
128 info.abilityName_ = "SetWindowCornerRadius";
129 info.bundleName_ = "SetWindowCornerRadius";
130 sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
131 EXPECT_NE(session, nullptr);
132 EXPECT_EQ(WSError::WS_OK, session->SetWindowCornerRadius(1.0f));
133
__anon5d4b48fa0402(float cornerRadius) 134 NotifySetWindowCornerRadiusFunc func = [](float cornerRadius) { return; };
135 session->onSetWindowCornerRadiusFunc_ = func;
136 EXPECT_EQ(WSError::WS_OK, session->SetWindowCornerRadius(1.0f));
137 }
138
139 /**
140 * @tc.name: AddSidebarBlur01
141 * @tc.desc: AddSidebarBlur01
142 * @tc.type: FUNC
143 */
144 HWTEST_F(SceneSessionAnimationTest, AddSidebarBlur01, TestSize.Level1)
145 {
146 SessionInfo info;
147 info.abilityName_ = "AddSidebarBlur01";
148 info.bundleName_ = "AddSidebarBlur01";
149 sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
150 EXPECT_NE(session, nullptr);
151 session->SetScreenId(defaultScreenSession_->GetScreenId());
152
153 struct RSSurfaceNodeConfig surfaceNodeConfig;
154 std::shared_ptr<RSSurfaceNode> surfaceNode = RSSurfaceNode::Create(surfaceNodeConfig);
155 EXPECT_EQ(nullptr, session->GetSurfaceNode());
156
157 session->AddSidebarBlur();
158 EXPECT_EQ(nullptr, session->blurRadiusValue_);
159 EXPECT_EQ(nullptr, session->blurSaturationValue_);
160 EXPECT_EQ(nullptr, session->blurBrightnessValue_);
161 EXPECT_EQ(nullptr, session->blurMaskColorValue_);
162
163 session->SetSurfaceNode(surfaceNode);
164 EXPECT_NE(nullptr, session->GetSurfaceNode());
165
166 AbilityRuntime::Context::applicationContext_ = std::make_shared<AbilityRuntime::ApplicationContext>();
167 std::shared_ptr<AbilityRuntime::ApplicationContext> appContext = AbilityRuntime::Context::GetApplicationContext();
168 EXPECT_NE(nullptr, appContext);
169
170 appContext->contextImpl_ = std::make_shared<AbilityRuntime::ContextImpl>();
171 appContext->contextImpl_->config_ = std::make_shared<AppExecFwk::Configuration>();
172 std::shared_ptr<AppExecFwk::Configuration> appContextConfig = appContext->GetConfiguration();
173 EXPECT_NE(nullptr, appContextConfig);
174
175 appContextConfig->AddItem(AAFwk::GlobalConfigurationKey::SYSTEM_COLORMODE,
176 AppExecFwk::ConfigurationInner::COLOR_MODE_DARK);
177
178 session->AddSidebarBlur();
179 EXPECT_NE(nullptr, session->blurRadiusValue_);
180 EXPECT_NE(nullptr, session->blurSaturationValue_);
181 EXPECT_NE(nullptr, session->blurBrightnessValue_);
182 EXPECT_NE(nullptr, session->blurMaskColorValue_);
183 }
184
185 /**
186 * @tc.name: AddSidebarBlur02
187 * @tc.desc: AddSidebarBlur02
188 * @tc.type: FUNC
189 */
190 HWTEST_F(SceneSessionAnimationTest, AddSidebarBlur02, TestSize.Level1)
191 {
192 SessionInfo info;
193 info.abilityName_ = "AddSidebarBlur02";
194 info.bundleName_ = "AddSidebarBlur02";
195 sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
196 EXPECT_NE(session, nullptr);
197 session->SetScreenId(defaultScreenSession_->GetScreenId());
198
199 struct RSSurfaceNodeConfig surfaceNodeConfig;
200 std::shared_ptr<RSSurfaceNode> surfaceNode = RSSurfaceNode::Create(surfaceNodeConfig);
201 EXPECT_EQ(nullptr, session->GetSurfaceNode());
202
203 session->AddSidebarBlur();
204 EXPECT_EQ(nullptr, session->blurRadiusValue_);
205 EXPECT_EQ(nullptr, session->blurSaturationValue_);
206 EXPECT_EQ(nullptr, session->blurBrightnessValue_);
207 EXPECT_EQ(nullptr, session->blurMaskColorValue_);
208
209 session->SetSurfaceNode(surfaceNode);
210 EXPECT_NE(nullptr, session->GetSurfaceNode());
211
212 AbilityRuntime::Context::applicationContext_ = std::make_shared<AbilityRuntime::ApplicationContext>();
213 std::shared_ptr<AbilityRuntime::ApplicationContext> appContext = AbilityRuntime::Context::GetApplicationContext();
214 EXPECT_NE(nullptr, appContext);
215
216 appContext->contextImpl_ = std::make_shared<AbilityRuntime::ContextImpl>();
217 appContext->contextImpl_->config_ = std::make_shared<AppExecFwk::Configuration>();
218 std::shared_ptr<AppExecFwk::Configuration> appContextConfig = appContext->GetConfiguration();
219 EXPECT_NE(nullptr, appContextConfig);
220
221 appContextConfig->AddItem(AAFwk::GlobalConfigurationKey::SYSTEM_COLORMODE,
222 AppExecFwk::ConfigurationInner::COLOR_MODE_LIGHT);
223
224 session->AddSidebarBlur();
225 EXPECT_NE(nullptr, session->blurRadiusValue_);
226 EXPECT_NE(nullptr, session->blurSaturationValue_);
227 EXPECT_NE(nullptr, session->blurBrightnessValue_);
228 EXPECT_NE(nullptr, session->blurMaskColorValue_);
229 }
230
231 /*
232 * @c.name: AddSidebarBlur03
233 * @c.desc: AddSidebarBlur03
234 * @c.type: FUNC
235 */
236 HWTEST_F(SceneSessionAnimationTest, AddSidebarBlur03, TestSize.Level1)
237 {
238 SessionInfo info;
239 info.abilityName_ = "AddSidebarBlur03";
240 info.bundleName_ = "AddSidebarBlur03";
241 sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
242 EXPECT_NE(session, nullptr);
243 session->SetScreenId(defaultScreenSession_->GetScreenId());
244
245 struct RSSurfaceNodeConfig surfaceNodeConfig;
246 std::shared_ptr<RSSurfaceNode> surfaceNode = RSSurfaceNode::Create(surfaceNodeConfig);
247 EXPECT_EQ(nullptr, session->GetSurfaceNode());
248 session->SetSurfaceNode(surfaceNode);
249 EXPECT_NE(nullptr, session->GetSurfaceNode());
250
251 AbilityRuntime::Context::applicationContext_ = std::make_shared<AbilityRuntime::ApplicationContext>();
252 std::shared_ptr<AbilityRuntime::ApplicationContext> appContext = AbilityRuntime::Context::GetApplicationContext();
253 EXPECT_NE(nullptr, appContext);
254
255 appContext->contextImpl_ = std::make_shared<AbilityRuntime::ContextImpl>();
256 appContext->contextImpl_->config_ = std::make_shared<AppExecFwk::Configuration>();
257 std::shared_ptr<AppExecFwk::Configuration> appContextConfig = appContext->GetConfiguration();
258 EXPECT_NE(nullptr, appContextConfig);
259
260 appContextConfig->AddItem(AAFwk::GlobalConfigurationKey::SYSTEM_COLORMODE,
261 AppExecFwk::ConfigurationInner::COLOR_MODE_DARK);
262
263 session->AddSidebarBlur();
264 float radiusOpenDark = session->blurRadiusValue_->Get();
265 float saturationOpenDark = session->blurSaturationValue_->Get();
266 float brightnessOpenDark = session->blurBrightnessValue_->Get();
267 Rosen::RSColor colorOpenDark = session->blurMaskColorValue_->Get();
268 EXPECT_EQ(SIDEBAR_DEFAULT_RADIUS_DARK, radiusOpenDark);
269 EXPECT_EQ(SIDEBAR_DEFAULT_SATURATION_DARK, saturationOpenDark);
270 EXPECT_EQ(SIDEBAR_DEFAULT_BRIGHTNESS_DARK, brightnessOpenDark);
271 EXPECT_EQ(SIDEBAR_DEFAULT_MASKCOLOR_DARK, colorOpenDark.AsArgbInt());
272 }
273
274 /**
275 * @tc.name: AddSidebarBlur04
276 * @tc.desc: AddSidebarBlur04
277 * @tc.type: FUNC
278 */
279 HWTEST_F(SceneSessionAnimationTest, AddSidebarBlur04, TestSize.Level1)
280 {
281 SessionInfo info;
282 info.abilityName_ = "AddSidebarBlur04";
283 info.bundleName_ = "AddSidebarBlur04";
284 sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
285 EXPECT_NE(session, nullptr);
286 session->SetScreenId(defaultScreenSession_->GetScreenId());
287
288 struct RSSurfaceNodeConfig surfaceNodeConfig;
289 std::shared_ptr<RSSurfaceNode> surfaceNode = RSSurfaceNode::Create(surfaceNodeConfig);
290 EXPECT_EQ(nullptr, session->GetSurfaceNode());
291 session->SetSurfaceNode(surfaceNode);
292 EXPECT_NE(nullptr, session->GetSurfaceNode());
293
294 AbilityRuntime::Context::applicationContext_ = std::make_shared<AbilityRuntime::ApplicationContext>();
295 std::shared_ptr<AbilityRuntime::ApplicationContext> appContext = AbilityRuntime::Context::GetApplicationContext();
296 EXPECT_NE(nullptr, appContext);
297
298 appContext->contextImpl_ = std::make_shared<AbilityRuntime::ContextImpl>();
299 appContext->contextImpl_->config_ = std::make_shared<AppExecFwk::Configuration>();
300 std::shared_ptr<AppExecFwk::Configuration> appContextConfig = appContext->GetConfiguration();
301 EXPECT_NE(nullptr, appContextConfig);
302
303 appContextConfig->AddItem(AAFwk::GlobalConfigurationKey::SYSTEM_COLORMODE,
304 AppExecFwk::ConfigurationInner::COLOR_MODE_LIGHT);
305
306 session->AddSidebarBlur();
307 float radiusOpenLight = session->blurRadiusValue_->Get();
308 float saturationOpenLight = session->blurSaturationValue_->Get();
309 float brightnessOpenLight = session->blurBrightnessValue_->Get();
310 Rosen::RSColor colorOpenLight = session->blurMaskColorValue_->Get();
311 EXPECT_EQ(SIDEBAR_DEFAULT_RADIUS_LIGHT, radiusOpenLight);
312 EXPECT_EQ(SIDEBAR_DEFAULT_SATURATION_LIGHT, saturationOpenLight);
313 EXPECT_EQ(SIDEBAR_DEFAULT_BRIGHTNESS_LIGHT, brightnessOpenLight);
314 EXPECT_EQ(SIDEBAR_DEFAULT_MASKCOLOR_LIGHT, colorOpenLight.AsArgbInt());
315 }
316
317 /**
318 * @tc.name: SetSidebarBlur01
319 * @tc.desc: SetSidebarBlur01
320 * @tc.type: FUNC
321 */
322 HWTEST_F(SceneSessionAnimationTest, SetSidebarBlur01, TestSize.Level1)
323 {
324 SessionInfo info;
325 info.abilityName_ = "SetSidebarBlur01";
326 info.bundleName_ = "SetSidebarBlur01";
327 sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
328 EXPECT_NE(session, nullptr);
329 session->SetScreenId(defaultScreenSession_->GetScreenId());
330
331 struct RSSurfaceNodeConfig surfaceNodeConfig;
332 std::shared_ptr<RSSurfaceNode> surfaceNode = RSSurfaceNode::Create(surfaceNodeConfig);
333 EXPECT_EQ(nullptr, session->GetSurfaceNode());
334
335 session->AddSidebarBlur();
336 EXPECT_EQ(nullptr, session->blurRadiusValue_);
337 EXPECT_EQ(nullptr, session->blurSaturationValue_);
338 EXPECT_EQ(nullptr, session->blurBrightnessValue_);
339 EXPECT_EQ(nullptr, session->blurMaskColorValue_);
340
341 session->SetSurfaceNode(surfaceNode);
342 EXPECT_NE(nullptr, session->GetSurfaceNode());
343
344 AbilityRuntime::Context::applicationContext_ = std::make_shared<AbilityRuntime::ApplicationContext>();
345 std::shared_ptr<AbilityRuntime::ApplicationContext> appContext = AbilityRuntime::Context::GetApplicationContext();
346 EXPECT_NE(nullptr, appContext);
347
348 appContext->contextImpl_ = std::make_shared<AbilityRuntime::ContextImpl>();
349 appContext->contextImpl_->config_ = std::make_shared<AppExecFwk::Configuration>();
350 std::shared_ptr<AppExecFwk::Configuration> appContextConfig = appContext->GetConfiguration();
351 EXPECT_NE(nullptr, appContextConfig);
352
353 appContextConfig->AddItem(AAFwk::GlobalConfigurationKey::SYSTEM_COLORMODE,
354 AppExecFwk::ConfigurationInner::COLOR_MODE_DARK);
355
356 session->AddSidebarBlur();
357 EXPECT_NE(nullptr, session->blurRadiusValue_);
358 EXPECT_NE(nullptr, session->blurSaturationValue_);
359 EXPECT_NE(nullptr, session->blurBrightnessValue_);
360 EXPECT_NE(nullptr, session->blurMaskColorValue_);
361 }
362
363 /**
364 * @tc.name: SetSidebarBlur02
365 * @tc.desc: SetSidebarBlur02
366 * @tc.type: FUNC
367 */
368 HWTEST_F(SceneSessionAnimationTest, SetSidebarBlur02, TestSize.Level1)
369 {
370 SessionInfo info;
371 info.abilityName_ = "SetSidebarBlur02";
372 info.bundleName_ = "SetSidebarBlur02";
373 sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
374 EXPECT_NE(session, nullptr);
375 session->SetScreenId(defaultScreenSession_->GetScreenId());
376
377 struct RSSurfaceNodeConfig surfaceNodeConfig;
378 std::shared_ptr<RSSurfaceNode> surfaceNode = RSSurfaceNode::Create(surfaceNodeConfig);
379 EXPECT_EQ(nullptr, session->GetSurfaceNode());
380
381 session->AddSidebarBlur();
382 EXPECT_EQ(nullptr, session->blurRadiusValue_);
383 EXPECT_EQ(nullptr, session->blurSaturationValue_);
384 EXPECT_EQ(nullptr, session->blurBrightnessValue_);
385 EXPECT_EQ(nullptr, session->blurMaskColorValue_);
386
387 session->SetSurfaceNode(surfaceNode);
388 EXPECT_NE(nullptr, session->GetSurfaceNode());
389
390 AbilityRuntime::Context::applicationContext_ = std::make_shared<AbilityRuntime::ApplicationContext>();
391 std::shared_ptr<AbilityRuntime::ApplicationContext> appContext = AbilityRuntime::Context::GetApplicationContext();
392 EXPECT_NE(nullptr, appContext);
393
394 appContext->contextImpl_ = std::make_shared<AbilityRuntime::ContextImpl>();
395 appContext->contextImpl_->config_ = std::make_shared<AppExecFwk::Configuration>();
396 std::shared_ptr<AppExecFwk::Configuration> appContextConfig = appContext->GetConfiguration();
397 EXPECT_NE(nullptr, appContextConfig);
398
399 appContextConfig->AddItem(AAFwk::GlobalConfigurationKey::SYSTEM_COLORMODE,
400 AppExecFwk::ConfigurationInner::COLOR_MODE_LIGHT);
401
402 session->AddSidebarBlur();
403 EXPECT_NE(nullptr, session->blurRadiusValue_);
404 EXPECT_NE(nullptr, session->blurSaturationValue_);
405 EXPECT_NE(nullptr, session->blurBrightnessValue_);
406 EXPECT_NE(nullptr, session->blurMaskColorValue_);
407 }
408
409 /**
410 * @tc.name: SetSidebarBlur03
411 * @tc.desc: SetSidebarBlur03
412 * @tc.type: FUNC
413 */
414 HWTEST_F(SceneSessionAnimationTest, SetSidebarBlur03, TestSize.Level1)
415 {
416 SessionInfo info;
417 info.abilityName_ = "SetSidebarBlur03";
418 info.bundleName_ = "SetSidebarBlur03";
419 sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
420 EXPECT_NE(session, nullptr);
421 session->SetScreenId(defaultScreenSession_->GetScreenId());
422
423 struct RSSurfaceNodeConfig surfaceNodeConfig;
424 std::shared_ptr<RSSurfaceNode> surfaceNode = RSSurfaceNode::Create(surfaceNodeConfig);
425 EXPECT_EQ(nullptr, session->GetSurfaceNode());
426 session->SetSurfaceNode(surfaceNode);
427 EXPECT_NE(nullptr, session->GetSurfaceNode());
428
429 AbilityRuntime::Context::applicationContext_ = std::make_shared<AbilityRuntime::ApplicationContext>();
430 std::shared_ptr<AbilityRuntime::ApplicationContext> appContext = AbilityRuntime::Context::GetApplicationContext();
431 EXPECT_NE(nullptr, appContext);
432
433 appContext->contextImpl_ = std::make_shared<AbilityRuntime::ContextImpl>();
434 appContext->contextImpl_->config_ = std::make_shared<AppExecFwk::Configuration>();
435 std::shared_ptr<AppExecFwk::Configuration> appContextConfig = appContext->GetConfiguration();
436 EXPECT_NE(nullptr, appContextConfig);
437
438 appContextConfig->AddItem(AAFwk::GlobalConfigurationKey::SYSTEM_COLORMODE,
439 AppExecFwk::ConfigurationInner::COLOR_MODE_DARK);
440
441 session->AddSidebarBlur();
442 session->SetSidebarBlur(false, false);
443 float radiusCloseDark = session->blurRadiusValue_->Get();
444 float saturationCloseDark = session->blurSaturationValue_->Get();
445 float brightnessCloseDark = session->blurBrightnessValue_->Get();
446 Rosen::RSColor colorCloseDark = session->blurMaskColorValue_->Get();
447 EXPECT_EQ(SIDEBAR_BLUR_NUMBER_ZERO, radiusCloseDark);
448 EXPECT_EQ(SIDEBAR_BLUR_NUMBER_ZERO, saturationCloseDark);
449 EXPECT_EQ(SIDEBAR_BLUR_NUMBER_ZERO, brightnessCloseDark);
450 EXPECT_EQ(SIDEBAR_SNAPSHOT_MASKCOLOR_DARK, colorCloseDark.AsArgbInt());
451
452 session->SetSidebarBlur(true, true);
453 float radiusOpenDark = session->blurRadiusValue_->Get();
454 float saturationOpenDark = session->blurSaturationValue_->Get();
455 float brightnessOpenDark = session->blurBrightnessValue_->Get();
456 Rosen::RSColor colorOpenDark = session->blurMaskColorValue_->Get();
457 EXPECT_EQ(SIDEBAR_DEFAULT_RADIUS_DARK, radiusOpenDark);
458 EXPECT_EQ(SIDEBAR_DEFAULT_SATURATION_DARK, saturationOpenDark);
459 EXPECT_EQ(SIDEBAR_DEFAULT_BRIGHTNESS_DARK, brightnessOpenDark);
460 EXPECT_EQ(SIDEBAR_DEFAULT_MASKCOLOR_DARK, colorOpenDark.AsArgbInt());
461 }
462
463 /**
464 * @tc.name: SetSidebarBlur04
465 * @tc.desc: SetSidebarBlur04
466 * @tc.type: FUNC
467 */
468 HWTEST_F(SceneSessionAnimationTest, SetSidebarBlur04, TestSize.Level1)
469 {
470 SessionInfo info;
471 info.abilityName_ = "SetSidebarBlur04";
472 info.bundleName_ = "SetSidebarBlur04";
473 sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
474 EXPECT_NE(session, nullptr);
475 session->SetScreenId(defaultScreenSession_->GetScreenId());
476
477 struct RSSurfaceNodeConfig surfaceNodeConfig;
478 std::shared_ptr<RSSurfaceNode> surfaceNode = RSSurfaceNode::Create(surfaceNodeConfig);
479 EXPECT_EQ(nullptr, session->GetSurfaceNode());
480 session->SetSurfaceNode(surfaceNode);
481 EXPECT_NE(nullptr, session->GetSurfaceNode());
482
483 AbilityRuntime::Context::applicationContext_ = std::make_shared<AbilityRuntime::ApplicationContext>();
484 std::shared_ptr<AbilityRuntime::ApplicationContext> appContext = AbilityRuntime::Context::GetApplicationContext();
485 EXPECT_NE(nullptr, appContext);
486
487 appContext->contextImpl_ = std::make_shared<AbilityRuntime::ContextImpl>();
488 appContext->contextImpl_->config_ = std::make_shared<AppExecFwk::Configuration>();
489 std::shared_ptr<AppExecFwk::Configuration> appContextConfig = appContext->GetConfiguration();
490 EXPECT_NE(nullptr, appContextConfig);
491
492 appContextConfig->AddItem(AAFwk::GlobalConfigurationKey::SYSTEM_COLORMODE,
493 AppExecFwk::ConfigurationInner::COLOR_MODE_LIGHT);
494
495 session->AddSidebarBlur();
496 session->SetSidebarBlur(false, false);
497 float radiusCloseLight = session->blurRadiusValue_->Get();
498 float saturationCloseLight = session->blurSaturationValue_->Get();
499 float brightnessCloseLight = session->blurBrightnessValue_->Get();
500 Rosen::RSColor colorCloseLight = session->blurMaskColorValue_->Get();
501 EXPECT_EQ(SIDEBAR_BLUR_NUMBER_ZERO, radiusCloseLight);
502 EXPECT_EQ(SIDEBAR_BLUR_NUMBER_ZERO, saturationCloseLight);
503 EXPECT_EQ(SIDEBAR_BLUR_NUMBER_ZERO, brightnessCloseLight);
504 EXPECT_EQ(SIDEBAR_SNAPSHOT_MASKCOLOR_LIGHT, colorCloseLight.AsArgbInt());
505
506 session->SetSidebarBlur(true, true);
507 float radiusOpenLight = session->blurRadiusValue_->Get();
508 float saturationOpenLight = session->blurSaturationValue_->Get();
509 float brightnessOpenLight = session->blurBrightnessValue_->Get();
510 Rosen::RSColor colorOpenLight = session->blurMaskColorValue_->Get();
511 EXPECT_EQ(SIDEBAR_DEFAULT_RADIUS_LIGHT, radiusOpenLight);
512 EXPECT_EQ(SIDEBAR_DEFAULT_SATURATION_LIGHT, saturationOpenLight);
513 EXPECT_EQ(SIDEBAR_DEFAULT_BRIGHTNESS_LIGHT, brightnessOpenLight);
514 EXPECT_EQ(SIDEBAR_DEFAULT_MASKCOLOR_LIGHT, colorOpenLight.AsArgbInt());
515 }
516
517 /**
518 * @tc.name: SetSidebarBlurMaximize01
519 * @tc.desc: SetSidebarBlurMaximize01
520 * @tc.type: FUNC
521 */
522 HWTEST_F(SceneSessionAnimationTest, SetSidebarBlurMaximize01, TestSize.Level1)
523 {
524 SessionInfo info;
525 info.abilityName_ = "SetSidebarBlurMaximize01";
526 info.bundleName_ = "SetSidebarBlurMaximize01";
527 sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
528 EXPECT_NE(session, nullptr);
529 session->SetScreenId(defaultScreenSession_->GetScreenId());
530
531 struct RSSurfaceNodeConfig surfaceNodeConfig;
532 std::shared_ptr<RSSurfaceNode> surfaceNode = RSSurfaceNode::Create(surfaceNodeConfig);
533 EXPECT_EQ(nullptr, session->GetSurfaceNode());
534 session->SetSurfaceNode(surfaceNode);
535 EXPECT_NE(nullptr, session->GetSurfaceNode());
536
537 AbilityRuntime::Context::applicationContext_ = std::make_shared<AbilityRuntime::ApplicationContext>();
538 std::shared_ptr<AbilityRuntime::ApplicationContext> appContext = AbilityRuntime::Context::GetApplicationContext();
539 EXPECT_NE(nullptr, appContext);
540
541 appContext->contextImpl_ = std::make_shared<AbilityRuntime::ContextImpl>();
542 appContext->contextImpl_->config_ = std::make_shared<AppExecFwk::Configuration>();
543 std::shared_ptr<AppExecFwk::Configuration> appContextConfig = appContext->GetConfiguration();
544 EXPECT_NE(nullptr, appContextConfig);
545
546 appContextConfig->AddItem(AAFwk::GlobalConfigurationKey::SYSTEM_COLORMODE,
547 AppExecFwk::ConfigurationInner::COLOR_MODE_DARK);
548
549 session->AddSidebarBlur();
550 session->SetSidebarBlurMaximize(false);
551 float radiusRecoverDark = session->blurRadiusValue_->Get();
552 float saturationRecoverDark = session->blurSaturationValue_->Get();
553 float brightnessRecoverDark = session->blurBrightnessValue_->Get();
554 Rosen::RSColor colorRecoverDark = session->blurMaskColorValue_->Get();
555 EXPECT_EQ(SIDEBAR_DEFAULT_RADIUS_DARK, radiusRecoverDark);
556 EXPECT_EQ(SIDEBAR_DEFAULT_SATURATION_DARK, saturationRecoverDark);
557 EXPECT_EQ(SIDEBAR_DEFAULT_BRIGHTNESS_DARK, brightnessRecoverDark);
558 EXPECT_EQ(SIDEBAR_DEFAULT_MASKCOLOR_DARK, colorRecoverDark.AsArgbInt());
559
560 session->SetSidebarBlurMaximize(true);
561 float radiusMaximizeDark = session->blurRadiusValue_->Get();
562 float saturationMaximizeDark = session->blurSaturationValue_->Get();
563 float brightnessMaximizeDark = session->blurBrightnessValue_->Get();
564 Rosen::RSColor colorMaximizeDark = session->blurMaskColorValue_->Get();
565 EXPECT_EQ(SIDEBAR_MAXIMIZE_RADIUS_DARK, radiusMaximizeDark);
566 EXPECT_EQ(SIDEBAR_MAXIMIZE_SATURATION_DARK, saturationMaximizeDark);
567 EXPECT_EQ(SIDEBAR_MAXIMIZE_BRIGHTNESS_DARK, brightnessMaximizeDark);
568 EXPECT_EQ(SIDEBAR_MAXIMIZE_MASKCOLOR_DARK, colorMaximizeDark.AsArgbInt());
569 }
570
571 /**
572 * @tc.name: SetSidebarBlurMaximize02
573 * @tc.desc: SetSidebarBlurMaximize02
574 * @tc.type: FUNC
575 */
576 HWTEST_F(SceneSessionAnimationTest, SetSidebarBlurMaximize02, TestSize.Level1)
577 {
578 SessionInfo info;
579 info.abilityName_ = "SetSidebarBlurMaximize02";
580 info.bundleName_ = "SetSidebarBlurMaximize02";
581 sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
582 EXPECT_NE(session, nullptr);
583 session->SetScreenId(defaultScreenSession_->GetScreenId());
584
585 struct RSSurfaceNodeConfig surfaceNodeConfig;
586 std::shared_ptr<RSSurfaceNode> surfaceNode = RSSurfaceNode::Create(surfaceNodeConfig);
587 EXPECT_EQ(nullptr, session->GetSurfaceNode());
588 session->SetSurfaceNode(surfaceNode);
589 EXPECT_NE(nullptr, session->GetSurfaceNode());
590
591 AbilityRuntime::Context::applicationContext_ = std::make_shared<AbilityRuntime::ApplicationContext>();
592 std::shared_ptr<AbilityRuntime::ApplicationContext> appContext = AbilityRuntime::Context::GetApplicationContext();
593 EXPECT_NE(nullptr, appContext);
594
595 appContext->contextImpl_ = std::make_shared<AbilityRuntime::ContextImpl>();
596 appContext->contextImpl_->config_ = std::make_shared<AppExecFwk::Configuration>();
597 std::shared_ptr<AppExecFwk::Configuration> appContextConfig = appContext->GetConfiguration();
598 EXPECT_NE(nullptr, appContextConfig);
599
600 appContextConfig->AddItem(AAFwk::GlobalConfigurationKey::SYSTEM_COLORMODE,
601 AppExecFwk::ConfigurationInner::COLOR_MODE_LIGHT);
602
603 session->AddSidebarBlur();
604 session->SetSidebarBlurMaximize(false);
605 float radiusRecoverLight = session->blurRadiusValue_->Get();
606 float saturationRecoverLight = session->blurSaturationValue_->Get();
607 float brightnessRecoverLight = session->blurBrightnessValue_->Get();
608 Rosen::RSColor colorRecoverLight = session->blurMaskColorValue_->Get();
609 EXPECT_EQ(SIDEBAR_DEFAULT_RADIUS_LIGHT, radiusRecoverLight);
610 EXPECT_EQ(SIDEBAR_DEFAULT_SATURATION_LIGHT, saturationRecoverLight);
611 EXPECT_EQ(SIDEBAR_DEFAULT_BRIGHTNESS_LIGHT, brightnessRecoverLight);
612 EXPECT_EQ(SIDEBAR_DEFAULT_MASKCOLOR_LIGHT, colorRecoverLight.AsArgbInt());
613
614 session->SetSidebarBlurMaximize(true);
615 float radiusMaximizeLight = session->blurRadiusValue_->Get();
616 float saturationMaximizeLight = session->blurSaturationValue_->Get();
617 float brightnessMaximizeLight = session->blurBrightnessValue_->Get();
618 Rosen::RSColor colorMaximizeLight = session->blurMaskColorValue_->Get();
619 EXPECT_EQ(SIDEBAR_MAXIMIZE_RADIUS_LIGHT, radiusMaximizeLight);
620 EXPECT_EQ(SIDEBAR_MAXIMIZE_SATURATION_LIGHT, saturationMaximizeLight);
621 EXPECT_EQ(SIDEBAR_MAXIMIZE_BRIGHTNESS_LIGHT, brightnessMaximizeLight);
622 EXPECT_EQ(SIDEBAR_MAXIMIZE_MASKCOLOR_LIGHT, colorMaximizeLight.AsArgbInt());
623 }
624
625 /**
626 * @tc.name: SetWindowShadowsCallback
627 * @tc.desc: SetWindowShadowsCallback
628 * @tc.type: FUNC
629 */
630 HWTEST_F(SceneSessionAnimationTest, SetWindowShadowsCallback, TestSize.Level1)
631 {
632 SessionInfo info;
633 info.abilityName_ = "SetWindowShadowsCallback";
634 info.bundleName_ = "SetWindowShadowsCallback";
635 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
636
__anon5d4b48fa0502(ShadowsInfo shadowsInfo) 637 NotifySetWindowShadowsFunc func = [](ShadowsInfo shadowsInfo) {
638 return;
639 };
640 sceneSession->SetWindowShadowsCallback(std::move(func));
641 ASSERT_NE(nullptr, sceneSession->onSetWindowShadowsFunc_);
642 }
643
644 /**
645 * @tc.name: OnSetWindowShadows
646 * @tc.desc: OnSetWindowShadows
647 * @tc.type: FUNC
648 */
649 HWTEST_F(SceneSessionAnimationTest, OnSetWindowShadows, TestSize.Level1)
650 {
651 SessionInfo info;
652 info.abilityName_ = "OnSetWindowShadows";
653 info.bundleName_ = "OnSetWindowShadows";
654 sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
655 EXPECT_NE(session, nullptr);
656
657 ShadowsInfo shadowsInfo = { 20.0, "#FF0000", 0.0, 0.0, true, true, true, true };
658 EXPECT_EQ(WSError::WS_OK, session->SetWindowShadows(shadowsInfo));
659
__anon5d4b48fa0602(ShadowsInfo shadowsInfo) 660 NotifySetWindowShadowsFunc func = [](ShadowsInfo shadowsInfo) {
661 return;
662 };
663 session->onSetWindowShadowsFunc_ = func;
664 EXPECT_EQ(WSError::WS_OK, session->SetWindowShadows(shadowsInfo));
665 }
666 } // namespace
667 } // namespace Rosen
668 } // namespace OHOS