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 <bundle_mgr_interface.h>
17 #include <bundlemgr/launcher_service.h>
18 #include <gtest/gtest.h>
19
20 #include "interfaces/include/ws_common.h"
21 #include "iremote_object_mocker.h"
22 #include "screen_session_manager/include/screen_session_manager_client.h"
23 #include "session_manager/include/scene_session_manager.h"
24 #include "session_info.h"
25 #include "session/host/include/scene_session.h"
26
27 using namespace testing;
28 using namespace testing::ext;
29
30 namespace OHOS {
31 namespace Rosen {
32 namespace {
33 const std::string EMPTY_DEVICE_ID = "";
34 constexpr float SINGLE_HAND_SCALE = 0.75f;
35 constexpr float SINGLE_HAND_DEFAULT_SCALE = 1.0f;
36 }
37 class SceneSessionManagerLayoutTest : public testing::Test {
38 public:
39 static void SetUpTestCase();
40 static void TearDownTestCase();
41 void SetUp() override;
42 void TearDown() override;
43 static sptr<SceneSessionManager> ssm_;
44 private:
45 static constexpr uint32_t WAIT_SYNC_IN_NS = 200000;
46 };
47
48 sptr<SceneSessionManager> SceneSessionManagerLayoutTest::ssm_ = nullptr;
49
SetUpTestCase()50 void SceneSessionManagerLayoutTest::SetUpTestCase()
51 {
52 ssm_ = &SceneSessionManager::GetInstance();
53 }
54
TearDownTestCase()55 void SceneSessionManagerLayoutTest::TearDownTestCase()
56 {
57 ssm_ = nullptr;
58 }
59
SetUp()60 void SceneSessionManagerLayoutTest::SetUp()
61 {
62 ssm_->sceneSessionMap_.clear();
63 }
64
TearDown()65 void SceneSessionManagerLayoutTest::TearDown()
66 {
67 usleep(WAIT_SYNC_IN_NS);
68 ssm_->sceneSessionMap_.clear();
69 }
70
71 namespace {
72 /**
73 * @tc.name: GetNormalSingleHandTransform
74 * @tc.desc: test function : GetNormalSingleHandTransform
75 * @tc.type: FUNC
76 */
77 HWTEST_F(SceneSessionManagerLayoutTest, GetNormalSingleHandTransform, Function | SmallTest | Level3)
78 {
79 SingleHandTransform preTransform = ssm_->singleHandTransform_;
80 ssm_->singleHandTransform_.posX = 100;
81 ASSERT_EQ(100, ssm_->GetNormalSingleHandTransform().posX);
82 ssm_->singleHandTransform_ = preTransform;
83 }
84
85 /**
86 * @tc.name: NotifySingleHandInfoChange_TestUIType
87 * @tc.desc: test function : NotifySingleHandInfoChange
88 * @tc.type: FUNC
89 */
90 HWTEST_F(SceneSessionManagerLayoutTest, NotifySingleHandInfoChange_TestUIType, Function | SmallTest | Level3)
91 {
92 SingleHandTransform singleHandTransform;
93 ssm_->singleHandTransform_ = singleHandTransform;
94 float singleHandScaleX = SINGLE_HAND_SCALE;
95 float singleHandScaleY = SINGLE_HAND_SCALE;
96 SingleHandMode singleHandMode = SingleHandMode::LEFT;
97 ScreenSessionManagerClient::GetInstance().screenSessionMap_.clear();
98 sptr<ScreenSession> screenSession = sptr<ScreenSession>::MakeSptr();
99 ScreenSessionManagerClient::GetInstance().screenSessionMap_.insert(std::make_pair(0, screenSession));
100
101 ssm_->systemConfig_.uiType_ = UI_TYPE_PC;
102 ssm_->NotifySingleHandInfoChange(singleHandScaleX, singleHandScaleY, singleHandMode);
103 usleep(WAIT_SYNC_IN_NS);
104 ASSERT_NE(singleHandScaleX, ssm_->singleHandTransform_.scaleX);
105
106 ssm_->systemConfig_.uiType_ = UI_TYPE_PHONE;
107 ssm_->NotifySingleHandInfoChange(singleHandScaleX, singleHandScaleY, singleHandMode);
108 usleep(WAIT_SYNC_IN_NS);
109 ASSERT_EQ(singleHandScaleX, ssm_->singleHandTransform_.scaleX);
110 ssm_->singleHandTransform_ = singleHandTransform;
111 }
112
113 /**
114 * @tc.name: NotifySingleHandInfoChange_TestWindowName
115 * @tc.desc: test function : NotifySingleHandInfoChange
116 * @tc.type: FUNC
117 */
118 HWTEST_F(SceneSessionManagerLayoutTest, NotifySingleHandInfoChange_TestWindowName, Function | SmallTest | Level3)
119 {
120 SingleHandTransform singleHandTransform;
121 ssm_->singleHandTransform_ = singleHandTransform;
122 SessionInfo sessionInfo;
123 sessionInfo.bundleName_ = "OneHandModeBackground_testWindow";
124 sessionInfo.abilityName_ = "OneHandModeBackground_testWindow";
125 sptr<SceneSession> sceneSession = ssm_->CreateSceneSession(sessionInfo, nullptr);
126 ASSERT_NE(sceneSession, nullptr);
127 sceneSession->property_->SetWindowName("OneHandModeBackground_testWindow");
128 ssm_->sceneSessionMap_.insert({sceneSession->GetPersistentId(), sceneSession});
129 ScreenSessionManagerClient::GetInstance().screenSessionMap_.clear();
130 sptr<ScreenSession> screenSession = sptr<ScreenSession>::MakeSptr();
131 ScreenSessionManagerClient::GetInstance().screenSessionMap_.insert(std::make_pair(0, screenSession));
132 float singleHandScaleX = SINGLE_HAND_SCALE;
133 float singleHandScaleY = SINGLE_HAND_SCALE;
134 SingleHandMode singleHandMode = SingleHandMode::LEFT;
135 ssm_->systemConfig_.uiType_ = UI_TYPE_PHONE;
136 ssm_->NotifySingleHandInfoChange(singleHandScaleX, singleHandScaleY, singleHandMode);
137 usleep(WAIT_SYNC_IN_NS);
138 ASSERT_NE(singleHandScaleX, sceneSession->singleHandTransform_.scaleX);
139 }
140
141 /**
142 * @tc.name: NotifySingleHandInfoChange_TestDisplayId
143 * @tc.desc: test function : NotifySingleHandInfoChange
144 * @tc.type: FUNC
145 */
146 HWTEST_F(SceneSessionManagerLayoutTest, NotifySingleHandInfoChange_TestDisplayId, Function | SmallTest | Level3)
147 {
148 SingleHandTransform singleHandTransform;
149 ssm_->singleHandTransform_ = singleHandTransform;
150 float singleHandScaleX = SINGLE_HAND_SCALE;
151 float singleHandScaleY = SINGLE_HAND_SCALE;
152 SingleHandMode singleHandMode = SingleHandMode::LEFT;
153 ssm_->systemConfig_.uiType_ = UI_TYPE_PHONE;
154 ScreenSessionManagerClient::GetInstance().screenSessionMap_.clear();
155 sptr<ScreenSession> screenSession = sptr<ScreenSession>::MakeSptr();
156 ScreenSessionManagerClient::GetInstance().screenSessionMap_.insert(std::make_pair(0, screenSession));
157 SessionInfo sessionInfo;
158 sessionInfo.bundleName_ = "NotifySingleHandInfoChange_TestDisplayId";
159 sessionInfo.abilityName_ = "NotifySingleHandInfoChange_TestDisplayId";
160 sptr<SceneSession> sceneSession = ssm_->CreateSceneSession(sessionInfo, nullptr);
161 ASSERT_NE(sceneSession, nullptr);
162
163 sceneSession->GetSessionProperty()->SetDisplayId(2025);
164 ssm_->sceneSessionMap_.insert({sceneSession->GetPersistentId(), sceneSession});
165 ssm_->NotifySingleHandInfoChange(singleHandScaleX, singleHandScaleY, singleHandMode);
166 usleep(WAIT_SYNC_IN_NS);
167 ASSERT_NE(singleHandScaleX, sceneSession->singleHandTransform_.scaleX);
168
169 sceneSession->GetSessionProperty()->SetDisplayId(0);
170 ssm_->NotifySingleHandInfoChange(singleHandScaleX, singleHandScaleY, singleHandMode);
171 usleep(WAIT_SYNC_IN_NS);
172 ASSERT_EQ(singleHandScaleX, sceneSession->singleHandTransform_.scaleX);
173 ssm_->singleHandTransform_ = singleHandTransform;
174 }
175
176 /**
177 * @tc.name: NotifySingleHandInfoChange_TestMode
178 * @tc.desc: test function : NotifySingleHandInfoChange
179 * @tc.type: FUNC
180 */
181 HWTEST_F(SceneSessionManagerLayoutTest, NotifySingleHandInfoChange_TestMode, Function | SmallTest | Level3)
182 {
183 SingleHandTransform singleHandTransform;
184 ssm_->singleHandTransform_ = singleHandTransform;
185 ssm_->systemConfig_.uiType_ = UI_TYPE_PHONE;
186 ScreenSessionManagerClient::GetInstance().screenSessionMap_.clear();
187 sptr<ScreenSession> screenSession = sptr<ScreenSession>::MakeSptr();
188 ScreenSessionManagerClient::GetInstance().screenSessionMap_.insert(std::make_pair(0, screenSession));
189
190 float singleHandScaleX = SINGLE_HAND_SCALE;
191 float singleHandScaleY = SINGLE_HAND_SCALE;
192 SingleHandMode singleHandMode = SingleHandMode::LEFT;
193 ssm_->NotifySingleHandInfoChange(singleHandScaleX, singleHandScaleY, singleHandMode);
194 usleep(WAIT_SYNC_IN_NS);
195 ASSERT_NE(0, ssm_->singleHandTransform_.posY);
196 ASSERT_EQ(0, ssm_->singleHandTransform_.posX);
197 ssm_->singleHandTransform_ = singleHandTransform;
198
199 singleHandScaleX = SINGLE_HAND_SCALE;
200 singleHandScaleY = SINGLE_HAND_SCALE;
201 singleHandMode = SingleHandMode::RIGHT;
202 ssm_->NotifySingleHandInfoChange(singleHandScaleX, singleHandScaleY, singleHandMode);
203 usleep(WAIT_SYNC_IN_NS);
204 ASSERT_NE(0, ssm_->singleHandTransform_.posY);
205 ASSERT_NE(0, ssm_->singleHandTransform_.posX);
206 ssm_->singleHandTransform_ = singleHandTransform;
207
208 singleHandScaleX = SINGLE_HAND_DEFAULT_SCALE;
209 singleHandScaleY = SINGLE_HAND_DEFAULT_SCALE;
210 singleHandMode = SingleHandMode::MIDDLE;
211 ssm_->NotifySingleHandInfoChange(singleHandScaleX, singleHandScaleY, singleHandMode);
212 usleep(WAIT_SYNC_IN_NS);
213 ASSERT_EQ(0, ssm_->singleHandTransform_.posY);
214 ASSERT_EQ(0, ssm_->singleHandTransform_.posX);
215 ssm_->singleHandTransform_ = singleHandTransform;
216 }
217
218 /**
219 * @tc.name: GetDisplaySizeById_TestDisplayId
220 * @tc.desc: test function : GetDisplaySizeById
221 * @tc.type: FUNC
222 */
223 HWTEST_F(SceneSessionManagerLayoutTest, GetDisplaySizeById_TestDisplayId, Function | SmallTest | Level3)
224 {
225 DisplayId displayId = 2025;
226 int32_t displayWidth = 0;
227 int32_t displayHeight = 0;
228 ASSERT_EQ(false, ssm_->GetDisplaySizeById(displayId, displayWidth, displayHeight));
229
230 displayId = 0;
231 ASSERT_EQ(true, ssm_->GetDisplaySizeById(displayId, displayWidth, displayHeight));
232 }
233 }
234 } // namespace Rosen
235 } // namespace OHOS
236