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 #include "event_manager_test.h"
16
17 #include "cooperate_context.h"
18 #include "cooperate_free.h"
19 #include "cooperate_in.h"
20 #include "cooperate_out.h"
21 #include "ddm_adapter.h"
22 #include "device.h"
23 #include "dsoftbus_adapter.h"
24 #include "event_manager.h"
25 #include "i_device.h"
26 #include "i_cooperate_state.h"
27 #include "input_adapter.h"
28 #include "ipc_skeleton.h"
29 #include "mouse_location.h"
30 #include "socket_session.h"
31 #include "state_machine.h"
32
33 namespace OHOS {
34 namespace Msdp {
35 namespace DeviceStatus {
36 using namespace testing::ext;
37 using namespace Cooperate;
38 namespace {
39 const std::string TEST_DEV_NODE { "/dev/input/TestDeviceNode" };
40 constexpr int32_t TIME_WAIT_FOR_OP_MS { 20 };
41 constexpr int32_t HOTAREA_500 { 500 };
42 constexpr int32_t HOTAREA_NEGATIVE_500 { -500 };
43 constexpr int32_t HOTAREA_NEGATIVE_200 { -200 };
44 constexpr int32_t HOTAREA_250 { 250 };
45 constexpr int32_t HOTAREA_200 { 200 };
46 constexpr int32_t HOTAREA_150 { 150 };
47 constexpr int32_t HOTAREA_50 { 50 };
48 std::shared_ptr<Context> g_context { nullptr };
49 std::shared_ptr<Context> g_contextOne { nullptr };
50 std::shared_ptr<HotplugObserver> g_observer { nullptr };
51 ContextService *g_instance = nullptr;
52 IContext *g_icontext { nullptr };
53 std::shared_ptr<SocketSession> g_session { nullptr };
54 DelegateTasks g_delegateTasks;
55 DeviceManager g_devMgr;
56 TimerManager g_timerMgr;
57 DragManager g_dragMgr;
58 SocketSessionManager g_socketSessionMgr;
59 std::unique_ptr<IDDMAdapter> g_ddm { nullptr };
60 std::unique_ptr<IInputAdapter> g_input { nullptr };
61 std::unique_ptr<IPluginManager> g_pluginMgr { nullptr };
62 std::unique_ptr<IDSoftbusAdapter> g_dsoftbus { nullptr };
63 std::shared_ptr<Cooperate::StateMachine> g_stateMachine { nullptr };
64 const std::string LOCAL_NETWORKID { "testLocalNetworkId" };
65 const std::string REMOTE_NETWORKID { "testRemoteNetworkId" };
66 } // namespace
67
ContextService()68 ContextService::ContextService()
69 {
70 }
71
~ContextService()72 ContextService::~ContextService()
73 {
74 }
75
GetDelegateTasks()76 IDelegateTasks& ContextService::GetDelegateTasks()
77 {
78 return g_delegateTasks;
79 }
80
GetDeviceManager()81 IDeviceManager& ContextService::GetDeviceManager()
82 {
83 return g_devMgr;
84 }
85
GetTimerManager()86 ITimerManager& ContextService::GetTimerManager()
87 {
88 return g_timerMgr;
89 }
90
GetDragManager()91 IDragManager& ContextService::GetDragManager()
92 {
93 return g_dragMgr;
94 }
95
GetInstance()96 ContextService* ContextService::GetInstance()
97 {
98 static std::once_flag flag;
99 std::call_once(flag, [&]() {
100 ContextService *cooContext = new (std::nothrow) ContextService();
101 CHKPL(cooContext);
102 g_instance = cooContext;
103 });
104 return g_instance;
105 }
106
GetSocketSessionManager()107 ISocketSessionManager& ContextService::GetSocketSessionManager()
108 {
109 return g_socketSessionMgr;
110 }
111
GetDDM()112 IDDMAdapter& ContextService::GetDDM()
113 {
114 return *g_ddm;
115 }
116
GetPluginManager()117 IPluginManager& ContextService::GetPluginManager()
118 {
119 return *g_pluginMgr;
120 }
121
GetInput()122 IInputAdapter& ContextService::GetInput()
123 {
124 return *g_input;
125 }
126
GetDSoftbus()127 IDSoftbusAdapter& ContextService::GetDSoftbus()
128 {
129 return *g_dsoftbus;
130 }
131
NotifyCooperate()132 void EventManagerTest::NotifyCooperate()
133 {
134 int32_t errCode { static_cast<int32_t>(CoordinationErrCode::COORDINATION_OK) };
135 EventManager::CooperateStateNotice cooperateStateNotice{IPCSkeleton::GetCallingPid(),
136 MessageId::COORDINATION_MESSAGE, 1, true, errCode};
137 g_contextOne->eventMgr_.NotifyCooperateState(cooperateStateNotice);
138 g_context->eventMgr_.NotifyCooperateState(cooperateStateNotice);
139 g_socketSessionMgr.AddSession(g_session);
140 g_context->eventMgr_.NotifyCooperateState(cooperateStateNotice);
141 g_context->eventMgr_.GetCooperateState(cooperateStateNotice);
142 }
143
CheckInHot()144 void EventManagerTest::CheckInHot()
145 {
146 g_context->hotArea_.displayX_ = 0;
147 g_context->hotArea_.height_ = HOTAREA_500;
148 g_context->hotArea_.displayY_ = HOTAREA_250;
149 g_context->hotArea_.CheckInHotArea();
150 g_context->hotArea_.width_ = HOTAREA_200;
151 g_context->hotArea_.displayX_ = HOTAREA_150;
152 g_context->hotArea_.height_ = HOTAREA_500;
153 g_context->hotArea_.displayY_ = HOTAREA_250;
154 g_context->hotArea_.CheckInHotArea();
155 g_context->hotArea_.displayY_ = HOTAREA_50;
156 g_context->hotArea_.width_ = HOTAREA_500;
157 g_context->hotArea_.displayX_ = HOTAREA_250;
158 g_context->hotArea_.CheckInHotArea();
159 g_context->hotArea_.height_ = HOTAREA_500;
160 g_context->hotArea_.displayY_ = HOTAREA_500;
161 g_context->hotArea_.width_ = HOTAREA_500;
162 g_context->hotArea_.displayX_ = HOTAREA_250;
163 g_context->hotArea_.CheckInHotArea();
164 g_context->hotArea_.height_ = HOTAREA_500;
165 g_context->hotArea_.displayY_ = HOTAREA_NEGATIVE_500;
166 g_context->hotArea_.width_ = HOTAREA_500;
167 g_context->hotArea_.displayX_ = HOTAREA_NEGATIVE_200;
168 g_context->hotArea_.CheckInHotArea();
169 }
170
SetUpTestCase()171 void EventManagerTest::SetUpTestCase() {}
172
SetUp()173 void EventManagerTest::SetUp()
174 {
175 g_ddm = std::make_unique<DDMAdapter>();
176 g_input = std::make_unique<InputAdapter>();
177 g_dsoftbus = std::make_unique<DSoftbusAdapter>();
178 g_contextOne = std::make_shared<Context>(g_icontext);
179 auto env = ContextService::GetInstance();
180 g_context = std::make_shared<Context>(env);
181 int32_t moduleType = 1;
182 int32_t tokenType = 1;
183 int32_t uid = IPCSkeleton::GetCallingUid();
184 int32_t pid = IPCSkeleton::GetCallingPid();
185 int32_t sockFds[2] { -1, -1 };
186 g_session = std::make_shared<SocketSession>("test", moduleType, tokenType, sockFds[0], uid, pid);
187 }
188
TearDown()189 void EventManagerTest::TearDown()
190 {
191 g_context = nullptr;
192 g_contextOne = nullptr;
193 g_session = nullptr;
194 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
195 }
196
OnThreeStates(const CooperateEvent & event)197 void EventManagerTest::OnThreeStates(const CooperateEvent &event)
198 {
199 auto env = ContextService::GetInstance();
200 Context cooperateContext(env);
201 g_stateMachine = std::make_shared<Cooperate::StateMachine>(env);
202 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_OUT;
203 g_stateMachine->OnEvent(cooperateContext, event);
204 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
205 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_IN;
206 g_stateMachine->OnEvent(cooperateContext, event);
207 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
208 g_stateMachine->current_ = CooperateState::COOPERATE_STATE_FREE;
209 g_stateMachine->OnEvent(cooperateContext, event);
210 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
211 }
212
213 class CooperateObserver final : public ICooperateObserver {
214 public:
215 CooperateObserver() = default;
216 virtual ~CooperateObserver() = default;
217
IsAllowCooperate()218 virtual bool IsAllowCooperate()
219 {
220 return true;
221 }
OnStartCooperate(StartCooperateData & data)222 virtual void OnStartCooperate(StartCooperateData &data) {}
OnRemoteStartCooperate(RemoteStartCooperateData & data)223 virtual void OnRemoteStartCooperate(RemoteStartCooperateData &data) {}
OnStopCooperate(const std::string & remoteNetworkId)224 virtual void OnStopCooperate(const std::string &remoteNetworkId) {}
OnTransitionOut(const std::string & remoteNetworkId,const CooperateInfo & cooperateInfo)225 virtual void OnTransitionOut(const std::string &remoteNetworkId, const CooperateInfo &cooperateInfo) {}
OnTransitionIn(const std::string & remoteNetworkId,const CooperateInfo & cooperateInfo)226 virtual void OnTransitionIn(const std::string &remoteNetworkId, const CooperateInfo &cooperateInfo) {}
OnBack(const std::string & remoteNetworkId,const CooperateInfo & cooperateInfo)227 virtual void OnBack(const std::string &remoteNetworkId, const CooperateInfo &cooperateInfo) {}
OnRelay(const std::string & remoteNetworkId,const CooperateInfo & cooperateInfo)228 virtual void OnRelay(const std::string &remoteNetworkId, const CooperateInfo &cooperateInfo) {}
OnReset()229 virtual void OnReset() {}
CloseDistributedFileConnection(const std::string & remoteNetworkId)230 virtual void CloseDistributedFileConnection(const std::string &remoteNetworkId) {}
231 };
232
233 /**
234 * @tc.name: stateMachine_test136
235 * @tc.desc: Test cooperate plugin
236 * @tc.type: FUNC
237 * @tc.require:
238 */
239 HWTEST_F(EventManagerTest, stateMachine_test136, TestSize.Level1)
240 {
241 CALL_TEST_DEBUG;
242
243 DSoftbusCooperateOptions result {
244 .networkId = "test",
245 .originNetworkId = "test",
246 .success = true,
247 .cooperateOptions = CooperateOptions {
248 .displayX = 500,
249 .displayY = 500,
250 .displayId = -500
251 }
252 };
253 ASSERT_NO_FATAL_FAILURE(g_context->AdjustPointerPos(result));
254 }
255
256 /**
257 * @tc.name: EventManagerTest1
258 * @tc.desc: cooperate plugin
259 * @tc.type: FUNC
260 * @tc.require:
261 */
262 HWTEST_F(EventManagerTest, EventManagerTest001, TestSize.Level1)
263 {
264 CALL_TEST_DEBUG;
265 RegisterListenerEvent registerListenerEvent{IPCSkeleton::GetCallingPid(), 1};
266 g_context->eventMgr_.RegisterListener(registerListenerEvent);
267 g_context->eventMgr_.RegisterListener(registerListenerEvent);
268
269 EnableCooperateEvent enableCooperateEvent{1, 1, 1};
270 g_context->eventMgr_.EnableCooperate(enableCooperateEvent);
271 g_context->eventMgr_.DisableCooperate(registerListenerEvent);
272
273 StartCooperateEvent event {
274 .pid = IPCSkeleton::GetCallingPid(),
275 .userData = 1,
276 .remoteNetworkId = "test",
277 .startDeviceId = 1,
278 .errCode = std::make_shared<std::promise<int32_t>>(),
279 };
280 g_context->eventMgr_.StartCooperate(event);
281 DSoftbusStartCooperate startEvent {
282 .networkId = "test",
283 .success = true,
284 };
285 g_context->eventMgr_.StartCooperateFinish(startEvent);
286 g_context->eventMgr_.RemoteStart(startEvent);
287 g_context->eventMgr_.RemoteStartFinish(startEvent);
288 StopCooperateEvent stopEvent {
289 .pid = IPCSkeleton::GetCallingPid(),
290 .userData = 1,
291 .isUnchained = true,
292 };
293 g_context->eventMgr_.OnUnchain(stopEvent);
294 g_context->eventMgr_.StopCooperate(stopEvent);
295
296 DDMBoardOnlineEvent dDMBoardOnlineEvent {
297 .networkId = "test",
298 .normal = true,
299 };
300 g_context->eventMgr_.StopCooperateFinish(dDMBoardOnlineEvent);
301 g_context->eventMgr_.RemoteStopFinish(dDMBoardOnlineEvent);
302 g_context->eventMgr_.OnProfileChanged(dDMBoardOnlineEvent);
303 g_context->eventMgr_.OnSoftbusSessionClosed(dDMBoardOnlineEvent);
304 NotifyCooperate();
305 g_context->eventMgr_.OnSoftbusSessionClosed(dDMBoardOnlineEvent);
306 g_context->eventMgr_.RemoteStop(dDMBoardOnlineEvent);
307 g_context->eventMgr_.UnregisterListener(registerListenerEvent);
308 NetPacket packet1(MessageId::INVALID);
309 bool ret = g_context->dsoftbus_.OnPacket("test", packet1);
310 EXPECT_FALSE(ret);
311 }
312
313 /**
314 * @tc.name: EventManagerTest002
315 * @tc.desc: cooperate plugin
316 * @tc.type: FUNC
317 * @tc.require:
318 */
319 HWTEST_F(EventManagerTest, EventManagerTest002, TestSize.Level1)
320 {
321 CALL_TEST_DEBUG;
322 StartWithOptionsEvent result {
323 .pid = IPCSkeleton::GetCallingPid(),
324 .userData = 1,
325 .remoteNetworkId = "test",
326 .startDeviceId = 1,
327 .displayX = 500,
328 .displayY = 500,
329 .displayId = 1,
330 .errCode = std::make_shared<std::promise<int32_t>>()
331 };
332 ASSERT_NO_FATAL_FAILURE(g_context->eventMgr_.StartCooperateWithOptions(result));
333 }
334
335 /**
336 * @tc.name: EventManagerTest003
337 * @tc.desc: cooperate plugin
338 * @tc.type: FUNC
339 * @tc.require:
340 */
341 HWTEST_F(EventManagerTest, EventManagerTest003, TestSize.Level1)
342 {
343 CALL_TEST_DEBUG;
344 DSoftbusCooperateOptions result {
345 .networkId = LOCAL_NETWORKID
346 };
347 ASSERT_NO_FATAL_FAILURE(g_context->eventMgr_.StartCooperateWithOptionsFinish(result));
348 }
349
350 /**
351 * @tc.name: EventManagerTest004
352 * @tc.desc: cooperate plugin
353 * @tc.type: FUNC
354 * @tc.require:
355 */
356 HWTEST_F(EventManagerTest, EventManagerTest004, TestSize.Level1)
357 {
358 CALL_TEST_DEBUG;
359 DSoftbusCooperateOptions result {
360 .networkId = LOCAL_NETWORKID
361 };
362 ASSERT_NO_FATAL_FAILURE(g_context->eventMgr_.RemoteStartWithOptions(result));
363 }
364
365 /**
366 * @tc.name: EventManagerTest005
367 * @tc.desc: cooperate plugin
368 * @tc.type: FUNC
369 * @tc.require:
370 */
371 HWTEST_F(EventManagerTest, EventManagerTest005, TestSize.Level1)
372 {
373 CALL_TEST_DEBUG;
374 DSoftbusCooperateWithOptionsFinished result {
375 .success = false,
376 .errCode = static_cast<int32_t>(CoordinationErrCode::UNEXPECTED_START_CALL)
377 };
378 ASSERT_NO_FATAL_FAILURE(g_context->eventMgr_.RemoteStartWithOptionsFinish(result));
379 }
380
381 /**
382 * @tc.name: EventManagerTest6
383 * @tc.desc: cooperate plugin
384 * @tc.type: FUNC
385 * @tc.require:
386 */
387 HWTEST_F(EventManagerTest, EventManagerTest006, TestSize.Level1)
388 {
389 CALL_TEST_DEBUG;
390 RegisterListenerEvent registerListenerEvent{IPCSkeleton::GetCallingPid(), 1};
391 g_context->eventMgr_.RegisterListener(registerListenerEvent);
392 g_context->eventMgr_.RegisterListener(registerListenerEvent);
393
394 EnableCooperateEvent enableCooperateEvent{1, 1, 1};
395 g_context->eventMgr_.EnableCooperate(enableCooperateEvent);
396 g_context->eventMgr_.DisableCooperate(registerListenerEvent);
397
398 StartCooperateEvent event {
399 .pid = IPCSkeleton::GetCallingPid(),
400 .userData = 1,
401 .remoteNetworkId = "test",
402 .startDeviceId = 1,
403 .errCode = std::make_shared<std::promise<int32_t>>(),
404 .uid = 20020135,
405 };
406 g_context->eventMgr_.StartCooperate(event);
407 DSoftbusStartCooperate startEvent {
408 .networkId = "test",
409 .success = true,
410 };
411 g_context->eventMgr_.StartCooperateFinish(startEvent);
412 g_context->eventMgr_.RemoteStart(startEvent);
413 g_context->eventMgr_.RemoteStartFinish(startEvent);
414 StopCooperateEvent stopEvent {
415 .pid = IPCSkeleton::GetCallingPid(),
416 .userData = 1,
417 .isUnchained = true,
418 };
419 g_context->eventMgr_.OnUnchain(stopEvent);
420 g_context->eventMgr_.StopCooperate(stopEvent);
421
422 DDMBoardOnlineEvent dDMBoardOnlineEvent {
423 .networkId = "test",
424 .normal = true,
425 };
426 g_context->eventMgr_.StopCooperateFinish(dDMBoardOnlineEvent);
427 g_context->eventMgr_.RemoteStopFinish(dDMBoardOnlineEvent);
428 g_context->eventMgr_.OnProfileChanged(dDMBoardOnlineEvent);
429 g_context->eventMgr_.OnSoftbusSessionClosed(dDMBoardOnlineEvent);
430 NotifyCooperate();
431 g_context->eventMgr_.OnSoftbusSessionClosed(dDMBoardOnlineEvent);
432 g_context->eventMgr_.RemoteStop(dDMBoardOnlineEvent);
433 g_context->eventMgr_.UnregisterListener(registerListenerEvent);
434 NetPacket packet1(MessageId::INVALID);
435 bool ret = g_context->dsoftbus_.OnPacket("test", packet1);
436 EXPECT_FALSE(ret);
437 }
438 } // namespace DeviceStatus
439 } // namespace Msdp
440 } // namespace OHOS
441