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 "window_adapter.h"
19 #include "window_agent.h"
20 #include "window_property.h"
21 #include "session_manager.h"
22 #include "singleton_mocker.h"
23 #include "window_scene_session_impl.h"
24 #include "window_session_impl.h"
25 #include "modifier_render_thread/rs_modifiers_draw_thread.h"
26
27 using namespace testing;
28 using namespace testing::ext;
29
30 namespace OHOS {
31 namespace Rosen {
32 class WindowRecoverManagerTest : public testing::Test {
33 public:
34 static void SetUpTestCase();
35 static void TearDownTestCase();
36 void SetUp() override;
37 void TearDown() override;
38 };
39
SetUpTestCase()40 void WindowRecoverManagerTest::SetUpTestCase() {}
41
TearDownTestCase()42 void WindowRecoverManagerTest::TearDownTestCase()
43 {
44 #ifdef RS_ENABLE_VK
45 RSModifiersDrawThread::Destroy();
46 #endif
47 }
48
SetUp()49 void WindowRecoverManagerTest::SetUp() {}
50
TearDown()51 void WindowRecoverManagerTest::TearDown() {}
52
53 namespace {
54 /**
55 * @tc.name: RegisterSessionRecoverCallbackFunc
56 * @tc.desc: WindowAdapter/RegisterSessionRecoverCallbackFunc
57 * @tc.type: FUNC
58 */
59 HWTEST_F(WindowRecoverManagerTest, RegisterSessionRecoverCallbackFunc, TestSize.Level1)
60 {
61 WindowAdapter windowAdapter;
62 int32_t persistentId = 1;
__anon6ae8acdd0202null63 auto testFunc = [] { return WMError::WM_OK; };
64 windowAdapter.RegisterSessionRecoverCallbackFunc(persistentId, testFunc);
65 ASSERT_NE(windowAdapter.sessionRecoverCallbackFuncMap_[persistentId], nullptr);
66 }
67
68 /**
69 * @tc.name: RegisterSessionRecoverListener
70 * @tc.desc: RegisterSessionRecoverListener
71 * @tc.type: FUNC
72 */
73 HWTEST_F(WindowRecoverManagerTest, RegisterSessionRecoverListener, TestSize.Level1)
74 {
75 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
76 option->SetWindowName("RegisterSessionRecoverListener");
77 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
78 int32_t persistentId = windowSceneSessionImpl->property_->GetPersistentId();
79 WindowAdapter& windowAdapter = SingletonContainer::Get<WindowAdapter>();
80 windowSceneSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_INPUT_METHOD_FLOAT);
81 windowSceneSessionImpl->RegisterSessionRecoverListener(true);
82 ASSERT_EQ(windowAdapter.sessionRecoverCallbackFuncMap_.size(), 0);
83
84 windowSceneSessionImpl->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
85 windowSceneSessionImpl->property_->SetCollaboratorType(CollaboratorType::RESERVE_TYPE);
86 windowSceneSessionImpl->RegisterSessionRecoverListener(true);
87 ASSERT_EQ(windowAdapter.sessionRecoverCallbackFuncMap_.size(), 0);
88
89 windowSceneSessionImpl->property_->SetCollaboratorType(CollaboratorType::DEFAULT_TYPE);
90 windowSceneSessionImpl->RegisterSessionRecoverListener(true);
91 ASSERT_EQ(windowAdapter.sessionRecoverCallbackFuncMap_.size(), 1);
92 windowAdapter.UnregisterSessionRecoverCallbackFunc(persistentId);
93 ASSERT_EQ(windowAdapter.sessionRecoverCallbackFuncMap_.size(), 0);
94
95 windowSceneSessionImpl->state_ = WindowState::STATE_DESTROYED;
96 windowSceneSessionImpl->RegisterSessionRecoverListener(true);
97 ASSERT_EQ(windowAdapter.sessionRecoverCallbackFuncMap_.size(), 1);
98 windowAdapter.UnregisterSessionRecoverCallbackFunc(persistentId);
99 ASSERT_EQ(windowAdapter.sessionRecoverCallbackFuncMap_.size(), 0);
100
101 windowSceneSessionImpl->state_ = WindowState::STATE_SHOWN;
102 windowSceneSessionImpl->RegisterSessionRecoverListener(true);
103 EXPECT_EQ(CollaboratorType::DEFAULT_TYPE, windowSceneSessionImpl->property_->GetCollaboratorType());
104 ASSERT_EQ(windowAdapter.sessionRecoverCallbackFuncMap_.size(), 1);
105 windowAdapter.UnregisterSessionRecoverCallbackFunc(persistentId);
106 EXPECT_EQ(CollaboratorType::DEFAULT_TYPE, windowSceneSessionImpl->property_->GetCollaboratorType());
107 }
108
109 /**
110 * @tc.name: RecoverAndReconnectSceneSession
111 * @tc.desc: WindowAdapter/RecoverAndReconnectSceneSession
112 * @tc.type: FUNC
113 */
114 HWTEST_F(WindowRecoverManagerTest, RecoverAndReconnectSceneSession01, TestSize.Level1)
115 {
116 WindowAdapter windowAdapter;
117 sptr<ISessionStage> iSessionStage;
118 sptr<IWindowEventChannel> eventChannel;
119 sptr<ISession> session = nullptr;
120 sptr<IRemoteObject> token = nullptr;
121 auto ret1 =
122 windowAdapter.RecoverAndReconnectSceneSession(iSessionStage, eventChannel, nullptr, session, nullptr, token);
123 ASSERT_EQ(ret1, WMError::WM_OK);
124
125 windowAdapter.isProxyValid_ = true;
126 auto ret2 =
127 windowAdapter.RecoverAndReconnectSceneSession(iSessionStage, eventChannel, nullptr, session, nullptr, token);
128 ASSERT_EQ(ret2, WMError::WM_OK);
129
130 sptr<IRemoteObject> remotObject = nullptr;
131 windowAdapter.windowManagerServiceProxy_ = iface_cast<IWindowManager>(remotObject);
132 auto ret3 =
133 windowAdapter.RecoverAndReconnectSceneSession(iSessionStage, eventChannel, nullptr, session, nullptr, token);
134 ASSERT_EQ(ret3, WMError::WM_DO_NOTHING);
135 }
136
137 /**
138 * @tc.name: RecoverAndReconnectSceneSession
139 * @tc.desc: RecoverAndReconnectSceneSession
140 * @tc.type: FUNC
141 */
142 HWTEST_F(WindowRecoverManagerTest, RecoverAndReconnectSceneSession02, TestSize.Level1)
143 {
144 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
145 option->SetWindowName("RecoverAndReconnectSceneSession");
146 sptr<WindowSceneSessionImpl> windowSceneSessionImpl = sptr<WindowSceneSessionImpl>::MakeSptr(option);
147
148 auto ret = windowSceneSessionImpl->RecoverAndReconnectSceneSession();
149 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, ret);
150 windowSceneSessionImpl->isFocused_ = true;
151 ret = windowSceneSessionImpl->RecoverAndReconnectSceneSession();
152 EXPECT_EQ(WMError::WM_ERROR_NULLPTR, ret);
153 }
154
155 /**
156 * @tc.name: RecoverAndReconnectSceneSession
157 * @tc.desc: RecoverAndReconnectSceneSession
158 * @tc.type: FUNC
159 */
160 HWTEST_F(WindowRecoverManagerTest, RecoverAndReconnectSceneSession, TestSize.Level1)
161 {
162 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
163 option->SetWindowName("RecoverAndReconnectSceneSession");
164 sptr<WindowSceneSessionImpl> windowSceneSession = sptr<WindowSceneSessionImpl>::MakeSptr(option);
165 ASSERT_NE(nullptr, windowSceneSession);
166 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, windowSceneSession->RecoverAndReconnectSceneSession());
167 }
168
169 /**
170 * @tc.name: RegisterSessionRecoverListenerInputMethodFloat
171 * @tc.desc: Register session recover listener
172 * @tc.type: FUNC
173 */
174 HWTEST_F(WindowRecoverManagerTest, RegisterSessionRecoverListenerInputMethodFloat, TestSize.Level1)
175 {
176 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
177 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
178 window->property_->SetWindowType(WindowType::WINDOW_TYPE_INPUT_METHOD_FLOAT);
179 window->RegisterSessionRecoverListener(false);
180 ASSERT_EQ(SingletonContainer::Get<WindowAdapter>().sessionRecoverCallbackFuncMap_.size(), 0);
181 }
182
183 /**
184 * @tc.name: RegisterSessionRecoverListenerNonDefaultCollaboratorType01
185 * @tc.desc: Register session recover listener
186 * @tc.type: FUNC
187 */
188 HWTEST_F(WindowRecoverManagerTest,
189 RegisterSessionRecoverListenerNonDefaultCollaboratorType01, TestSize.Level1)
190 {
191 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
192 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
193 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
194 window->property_->SetCollaboratorType(CollaboratorType::OTHERS_TYPE);
195 window->RegisterSessionRecoverListener(false); // false is main window
196 ASSERT_EQ(SingletonContainer::Get<WindowAdapter>().sessionRecoverCallbackFuncMap_.size(), 0);
197 }
198
199 /**
200 * @tc.name: RegisterSessionRecoverListenerNonDefaultCollaboratorType02
201 * @tc.desc: Register session recover listener
202 * @tc.type: FUNC
203 */
204 HWTEST_F(WindowRecoverManagerTest,
205 RegisterSessionRecoverListenerNonDefaultCollaboratorType02, TestSize.Level1)
206 {
207 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
208 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
209 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
210 window->property_->SetCollaboratorType(CollaboratorType::OTHERS_TYPE);
211 window->RegisterSessionRecoverListener(true); // true is sub window
212 ASSERT_EQ(SingletonContainer::Get<WindowAdapter>().sessionRecoverCallbackFuncMap_.size(), 0);
213 }
214
215 /**
216 * @tc.name: RegisterSessionRecoverListenerSuccess01
217 * @tc.desc: Register session recover listener
218 * @tc.type: FUNC
219 */
220 HWTEST_F(WindowRecoverManagerTest, RegisterSessionRecoverListenerSuccess01, TestSize.Level1)
221 {
222 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
223 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
224 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
225 window->property_->SetCollaboratorType(CollaboratorType::DEFAULT_TYPE);
226 window->RegisterSessionRecoverListener(false); // false is main window
227 ASSERT_EQ(SingletonContainer::Get<WindowAdapter>().sessionRecoverCallbackFuncMap_.size(), 1);
228 SingletonContainer::Get<WindowAdapter>().sessionRecoverCallbackFuncMap_.clear();
229 }
230
231 /**
232 * @tc.name: RegisterSessionRecoverListenerSuccess02
233 * @tc.desc: Register session recover listener
234 * @tc.type: FUNC
235 */
236 HWTEST_F(WindowRecoverManagerTest, RegisterSessionRecoverListenerSuccess02, TestSize.Level1)
237 {
238 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
239 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
240 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
241 window->property_->SetCollaboratorType(CollaboratorType::DEFAULT_TYPE);
242 window->RegisterSessionRecoverListener(true); // true is sub window
243 ASSERT_EQ(SingletonContainer::Get<WindowAdapter>().sessionRecoverCallbackFuncMap_.size(), 1);
244 SingletonContainer::Get<WindowAdapter>().sessionRecoverCallbackFuncMap_.clear();
245 }
246
247 /**
248 * @tc.name: RegisterWindowRecoverStateChangeListener
249 * @tc.desc: Register Window Recover State Change Listener
250 * @tc.type: FUNC
251 */
252 HWTEST_F(WindowRecoverManagerTest, RegisterWindowRecoverStateChangeListener, TestSize.Level1)
253 {
254 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
255 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
256 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
257 window->property_->SetCollaboratorType(CollaboratorType::DEFAULT_TYPE);
258 window->RegisterWindowRecoverStateChangeListener();
259 EXPECT_NE(window->windowRecoverStateChangeFunc_, nullptr);
260 }
261
262 /**
263 * @tc.name: OnWindowRecoverStateChange
264 * @tc.desc: On Window Recover State Change
265 * @tc.type: FUNC
266 */
267 HWTEST_F(WindowRecoverManagerTest, OnWindowRecoverStateChange, TestSize.Level1)
268 {
269 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
270 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
271 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
272 window->property_->SetCollaboratorType(CollaboratorType::DEFAULT_TYPE);
273 window->OnWindowRecoverStateChange(false, WindowRecoverState::WINDOW_START_RECONNECT);
274 EXPECT_EQ(window->property_->GetWindowState(), window->state_);
275
276 window->OnWindowRecoverStateChange(false, WindowRecoverState::WINDOW_FINISH_RECONNECT);
277 EXPECT_EQ(window->property_->GetWindowState(), window->state_);
278 }
279
280 /**
281 * @tc.name: UpdateStartRecoverProperty
282 * @tc.desc: Update Start Recover Property
283 * @tc.type: FUNC
284 */
285 HWTEST_F(WindowRecoverManagerTest, UpdateStartRecoverProperty, TestSize.Level1)
286 {
287 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
288 sptr<WindowSceneSessionImpl> window = sptr<WindowSceneSessionImpl>::MakeSptr(option);
289 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
290 window->property_->SetCollaboratorType(CollaboratorType::DEFAULT_TYPE);
291 window->UpdateStartRecoverProperty(false);
292 EXPECT_EQ(window->property_->GetWindowState(), window->state_);
293
294 sptr<WindowOption> option2 = sptr<WindowOption>::MakeSptr();
295 sptr<WindowSceneSessionImpl> window2 = sptr<WindowSceneSessionImpl>::MakeSptr(option2);
296 window2->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
297 window2->property_->SetCollaboratorType(CollaboratorType::DEFAULT_TYPE);
298 window2->UpdateStartRecoverProperty(true);
299 EXPECT_EQ(window2->property_->GetWindowState(), window2->requestState_);
300 }
301
302 } // namespace
303 } // namespace Rosen
304 } // namespace OHOS