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 <future>
17 #include <optional>
18 #include <utility>
19 #include <vector>
20 
21 #include <unistd.h>
22 
23 #include "accesstoken_kit.h"
24 #include "display_manager.h"
25 #include <gtest/gtest.h>
26 #include "input_device.h"
27 #include "input_manager.h"
28 #include "parcel.h"
29 #include "pointer_event.h"
30 #include "securec.h"
31 
32 #include "coordination_message.h"
33 #include "devicestatus_define.h"
34 #include "devicestatus_errors.h"
35 #include "drag_data_util.h"
36 #include "interaction_manager.h"
37 #include "nativetoken_kit.h"
38 #include "token_setproc.h"
39 
40 #undef LOG_TAG
41 #define LOG_TAG "InteractionManagerTest"
42 
43 namespace OHOS {
44 namespace Msdp {
45 namespace DeviceStatus {
46 using namespace testing::ext;
47 namespace {
48 constexpr int32_t TIME_WAIT_FOR_OP_MS { 20 };
49 constexpr int32_t TIME_WAIT_FOR_INJECT_MS { 80 };
50 constexpr int32_t TIME_WAIT_FOR_TOUCH_DOWN_MS { 1000 };
51 constexpr int32_t PROMISE_WAIT_SPAN_MS { 2000 };
52 constexpr int32_t TEST_PIXEL_MAP_WIDTH { 200 };
53 constexpr int32_t TEST_PIXEL_MAP_HEIGHT { 200 };
54 constexpr int32_t MAX_PIXEL_MAP_WIDTH { 600 };
55 constexpr int32_t MAX_PIXEL_MAP_HEIGHT { 600 };
56 constexpr int32_t MOUSE_POINTER_ID { 0 };
57 constexpr int32_t TOUCH_POINTER_ID { 1 };
58 constexpr int32_t MOUSE_POINTER_ID_INJECT { 10000 };
59 constexpr int32_t TOUCH_POINTER_ID_INJECT { 20001 };
60 constexpr int32_t DISPLAY_ID { 0 };
61 constexpr int32_t DRAG_SRC_X { 0 };
62 constexpr int32_t DRAG_SRC_Y { 0 };
63 constexpr int32_t DRAG_DST_X { 500 };
64 constexpr int32_t DRAG_DST_Y { 500 };
65 constexpr int32_t DRAG_NUM { 1 };
66 constexpr int32_t INT32_BYTE { 4 };
67 constexpr int32_t SUBSTR_UDKEY_LEN { 6 };
68 constexpr int32_t WINDOW_ID { -1 };
69 constexpr int32_t HOT_AREA_COOR { 220 };
70 constexpr int32_t HOT_AREA_STEP { 150 };
71 constexpr int32_t HOT_AREA_SPAN { 70 };
72 constexpr uint32_t RECIVE_LOOP_COUNT { 5 };
73 constexpr uint32_t DEFAULT_ICON_COLOR { 0xFF };
74 constexpr bool HAS_CANCELED_ANIMATION { true };
75 constexpr bool HAS_CUSTOM_ANIMATION { true };
76 constexpr int32_t MOVE_STEP { 10 };
77 constexpr int32_t FOREGROUND_COLOR_IN { 0x33FF0000 };
78 constexpr int32_t FOREGROUND_COLOR_OUT { 0x00000000 };
79 constexpr int32_t ANIMATION_DURATION { 500 };
80 constexpr int32_t SRC_MAIN_WINDOW { 0 };
81 constexpr int32_t TARGET_MAIN_WINDOW { 0 };
82 constexpr int64_t DOWN_TIME { 1 };
83 const std::string UD_KEY { "Unified data key" };
84 const std::string SYSTEM_CORE { "system_core" };
85 const std::string SYSTEM_BASIC { "system_basic" };
86 const std::string CURVE_NAME { "cubic-bezier" };
87 const std::string EXTRA_INFO { "{ \"drag_corner_radius\": 20, \"drag_allow_distributed\": false }" };
88 const std::string FILTER_INFO { "{ \"dip_scale\": 3.5 }" };
89 int32_t g_deviceMouseId { -1 };
90 int32_t g_deviceTouchId { -1 };
91 int32_t g_screenWidth { 720 };
92 int32_t g_screenHeight { 1280 };
93 uint64_t g_tokenID { 0 };
94 const char* g_cores[] = { "ohos.permission.INPUT_MONITORING" };
95 const char* g_basics[] = { "ohos.permission.COOPERATE_MANAGER" };
96 const char* g_coresInject[] = { "ohos.permission.INJECT_INPUT_EVENT" };
97 std::shared_ptr<MMI::KeyEvent> g_keyEvent = MMI::KeyEvent::Create();
98 } // namespace
99 
100 class InteractionManagerTest : public testing::Test {
101 public:
102     void SetUp();
103     void TearDown();
104     static void SetUpTestCase();
105     static std::vector<int32_t> GetInputDeviceIds();
106     static std::shared_ptr<MMI::InputDevice> GetDevice(int32_t deviceId);
107     static std::pair<int32_t, int32_t> GetMouseAndTouch();
108     static std::shared_ptr<Media::PixelMap> CreatePixelMap(int32_t width, int32_t height);
109     static std::optional<DragData> CreateDragData(const std::pair<int32_t, int32_t> &pixelMapSize, int32_t sourceType,
110         int32_t pointerId, int32_t displayId, const std::pair<int32_t, int32_t> &location);
111     static MMI::PointerEvent::PointerItem CreatePointerItem(int32_t pointerId,
112         int32_t deviceId, const std::pair<int32_t, int32_t> &displayLocation, bool isPressed);
113     static std::shared_ptr<MMI::PointerEvent> SetupPointerEvent(const std::pair<int32_t, int32_t> &displayLocation,
114         int32_t action, int32_t sourceType, int32_t pointerId, bool isPressed);
115     static void SimulateDownPointerEvent(
116         const std::pair<int32_t, int32_t> &location, int32_t sourceType, int32_t pointerId);
117     static void SimulateUpPointerEvent(
118         const std::pair<int32_t, int32_t> &location, int32_t sourceType, int32_t pointerId);
119     static void SimulateMovePointerEvent(const std::pair<int32_t, int32_t> &srcLocation,
120         const std::pair<int32_t, int32_t> &dstLocation, int32_t sourceType, int32_t pointerId, bool isPressed);
121     static int32_t TestAddMonitor(std::shared_ptr<MMI::IInputEventConsumer> consumer);
122     static void TestRemoveMonitor(int32_t monitorId);
123     static void PrintDragData(const DragData &dragData);
124     static void SetPermission(const std::string &level, const char** perms, size_t permAmount);
125     static void RemovePermission();
126     static void SetupKeyEvent(int32_t action, int32_t key, bool isPressed);
127     static void ClearUpKeyEvent();
128     static void SimulateDownKeyEvent(int32_t key);
129     static void SimulateUpKeyEvent(int32_t key);
130     static void PrintDragAction(DragAction dragAction);
131     static void AssignToAnimation(PreviewAnimation &animation);
132     static void EnableCooperate();
133 };
134 
SetPermission(const std::string &level, const char** perms, size_t permAmount)135 void InteractionManagerTest::SetPermission(const std::string &level, const char** perms, size_t permAmount)
136 {
137     CALL_DEBUG_ENTER;
138     if (perms == nullptr || permAmount == 0) {
139         FI_HILOGE("The perms is empty");
140         return;
141     }
142 
143     NativeTokenInfoParams infoInstance = {
144         .dcapsNum = 0,
145         .permsNum = permAmount,
146         .aclsNum = 0,
147         .dcaps = nullptr,
148         .perms = perms,
149         .acls = nullptr,
150         .processName = "InteractionManagerTest",
151         .aplStr = level.c_str(),
152     };
153     g_tokenID = GetAccessTokenId(&infoInstance);
154     SetSelfTokenID(g_tokenID);
155     OHOS::Security::AccessToken::AccessTokenKit::AccessTokenKit::ReloadNativeTokenInfo();
156 }
157 
RemovePermission()158 void InteractionManagerTest::RemovePermission()
159 {
160     CALL_DEBUG_ENTER;
161     int32_t ret = OHOS::Security::AccessToken::AccessTokenKit::DeleteToken(g_tokenID);
162     if (ret != RET_OK) {
163         FI_HILOGE("Failed to remove permission");
164         return;
165     }
166 }
167 
168 class DragListenerTest : public IDragListener {
169 public:
DragListenerTest()170     DragListenerTest() {}
DragListenerTest(const std::string& name)171     explicit DragListenerTest(const std::string& name) : moduleName_(name) {}
172     void OnDragMessage(DragState state) override
173     {
174         if (moduleName_.empty()) {
175             moduleName_ = std::string("DragListenerTest");
176         }
177         FI_HILOGD("%{public}s, state:%{public}s", moduleName_.c_str(), PrintDragMessage(state).c_str());
178     }
179 private:
PrintDragMessage(DragState state)180     std::string PrintDragMessage(DragState state)
181     {
182         std::string type = "unknow";
183         const std::map<DragState, std::string> stateType = {
184             { DragState::ERROR, "error"},
185             { DragState::START, "start"},
186             { DragState::STOP, "stop"},
187             { DragState::CANCEL, "cancel"}
188         };
189         auto item = stateType.find(state);
190         if (item != stateType.end()) {
191             type = item->second;
192         }
193         return type;
194     }
195 private:
196     std::string moduleName_;
197 };
198 
199 class SubscriptListenerTest : public ISubscriptListener {
200 public:
SubscriptListenerTest()201     SubscriptListenerTest() {}
SubscriptListenerTest(const std::string& name)202     explicit SubscriptListenerTest(const std::string& name) : moduleName_(name) {}
203     void OnMessage(DragCursorStyle style) override
204     {
205         SetDragSyle(style);
206         if (moduleName_.empty()) {
207             moduleName_ = std::string("SubscriptListenerTest");
208         }
209         FI_HILOGD("Received notification event for subscriptListener, %{public}s, state:%{public}s",
210             moduleName_.c_str(), PrintStyleMessage(style).c_str());
211     }
212 
GetDragStyle()213     DragCursorStyle GetDragStyle()
214     {
215         return dragStyle_;
216     }
217 
218 private:
SetDragSyle(DragCursorStyle style)219     void SetDragSyle(DragCursorStyle style)
220     {
221         dragStyle_ = style;
222     }
223 
PrintStyleMessage(DragCursorStyle style)224     std::string PrintStyleMessage(DragCursorStyle style)
225     {
226         std::string type = "unknow";
227         const std::map<DragCursorStyle, std::string> cursorStyles = {
228             { DragCursorStyle::DEFAULT, "default"},
229             { DragCursorStyle::FORBIDDEN, "forbidden"},
230             { DragCursorStyle::COPY, "copy"},
231             { DragCursorStyle::MOVE, "move"}
232         };
233         auto item = cursorStyles.find(style);
234         if (item != cursorStyles.end()) {
235             type = item->second;
236         }
237         return type;
238     }
239 
240 private:
241     DragCursorStyle dragStyle_ { DragCursorStyle::DEFAULT };
242     std::string moduleName_;
243 };
244 
245 class UnitTestStartDragListener : public IStartDragListener {
246 public:
UnitTestStartDragListener(std::function<void(const DragNotifyMsg&)> function)247     explicit UnitTestStartDragListener(std::function<void(const DragNotifyMsg&)> function) : function_(function) { }
248     void OnDragEndMessage(const DragNotifyMsg &msg) override
249     {
250         FI_HILOGD("DisplayX:%{public}d, displayY:%{public}d, targetPid:%{public}d, result:%{public}d",
251             msg.displayX, msg.displayY, msg.targetPid, static_cast<int32_t>(msg.result));
252         if (function_ != nullptr) {
253             function_(msg);
254         }
255         FI_HILOGD("Unit test OnDragEndMessage");
256     }
257 
258     void OnHideIconMessage() override
259     {
260         FI_HILOGI("Unit test OnHideIconMessage");
261     }
262 private:
263     std::function<void(const DragNotifyMsg&)> function_;
264 };
265 
GetInputDeviceIds()266 std::vector<int32_t> InteractionManagerTest::GetInputDeviceIds()
267 {
268     std::vector<int32_t> realDeviceIds;
269     auto callback = [&realDeviceIds](std::vector<int32_t>& deviceIds) {
270         realDeviceIds = deviceIds;
271     };
272     int32_t ret = MMI::InputManager::GetInstance()->GetDeviceIds(callback);
273     if (ret != RET_OK) {
274         FI_HILOGE("Get device ids failed");
275         return {};
276     }
277     return realDeviceIds;
278 }
279 
GetDevice(int32_t deviceId)280 std::shared_ptr<MMI::InputDevice> InteractionManagerTest::GetDevice(int32_t deviceId)
281 {
282     std::shared_ptr<MMI::InputDevice> inputDevice;
283     auto callback = [&inputDevice](std::shared_ptr<MMI::InputDevice> device) {
284         inputDevice = device;
285     };
286     int32_t ret = MMI::InputManager::GetInstance()->GetDevice(deviceId, callback);
287     if (ret != RET_OK || inputDevice == nullptr) {
288         FI_HILOGE("Get device failed");
289         return nullptr;
290     }
291     return inputDevice;
292 }
293 
GetMouseAndTouch()294 std::pair<int32_t, int32_t> InteractionManagerTest::GetMouseAndTouch()
295 {
296     std::vector<int32_t> deviceIds = GetInputDeviceIds();
297     std::pair<int32_t, int32_t> mouseAndTouch { -1, -1 };
298     for (const auto& id : deviceIds) {
299         std::shared_ptr<MMI::InputDevice> device = GetDevice(id);
300         CHKPC(device);
301         if (device->HasCapability(MMI::InputDeviceCapability::INPUT_DEV_CAP_POINTER)) {
302             mouseAndTouch.first = device->GetId();
303         }
304         if (device->HasCapability(MMI::InputDeviceCapability::INPUT_DEV_CAP_TOUCH)) {
305             mouseAndTouch.second = device->GetId();
306         }
307     }
308     return mouseAndTouch;
309 }
310 
SetUpTestCase()311 void InteractionManagerTest::SetUpTestCase()
312 {
313     auto mouseAndTouch = GetMouseAndTouch();
314     g_deviceMouseId = mouseAndTouch.first;
315     g_deviceTouchId = mouseAndTouch.second;
316 }
317 
SetUp()318 void InteractionManagerTest::SetUp()
319 {
320     EnableCooperate();
321 }
322 
TearDown()323 void InteractionManagerTest::TearDown()
324 {
325     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
326 }
327 
EnableCooperate()328 void InteractionManagerTest::EnableCooperate()
329 {
330     SetPermission(SYSTEM_BASIC, g_basics, sizeof(g_basics) / sizeof(g_basics[0]));
331     std::promise<bool> promiseFlag;
332     std::future<bool> futureFlag = promiseFlag.get_future();
333     auto fun = [&promiseFlag](const std::string &listener, const CoordinationMsgInfo &coordinationMessages) {
334         FI_HILOGD("Prepare coordination success, listener:%{public}s", listener.c_str());
335         promiseFlag.set_value(true);
336     };
337     bool isCompatible = true;
338     int32_t ret = InteractionManager::GetInstance()->PrepareCoordination(fun, isCompatible);
339 #ifdef OHOS_BUILD_ENABLE_COORDINATION
340     if (ret == RET_OK) {
341         FI_HILOGI("PrepareCoordination successfully");
342     } else {
343         FI_HILOGE("PrepareCoordination failed");
344     }
345     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) != std::future_status::timeout);
346 #else
347     ASSERT_EQ(ret, ERROR_UNSUPPORT);
348 #endif // OHOS_BUILD_ENABLE_COORDINATION
349     RemovePermission();
350 }
351 
CreatePixelMap(int32_t width, int32_t height)352 std::shared_ptr<Media::PixelMap> InteractionManagerTest::CreatePixelMap(int32_t width, int32_t height)
353 {
354     CALL_DEBUG_ENTER;
355     OHOS::Media::InitializationOptions opts;
356     opts.size.width = width;
357     opts.size.height = height;
358     opts.pixelFormat = Media::PixelFormat::BGRA_8888;
359     opts.alphaType = Media::AlphaType::IMAGE_ALPHA_TYPE_OPAQUE;
360     opts.scaleMode = Media::ScaleMode::FIT_TARGET_SIZE;
361 
362     int32_t colorLen = width * height;
363     uint32_t* colors = new (std::nothrow) uint32_t[colorLen];
364     CHKPP(colors);
365     int32_t colorByteCount = colorLen * INT32_BYTE;
366     if (memset_s(colors, colorByteCount, DEFAULT_ICON_COLOR, colorByteCount) != EOK) {
367         delete[] colors;
368         FI_HILOGE("memset_s failed");
369         return nullptr;
370     }
371     std::shared_ptr<Media::PixelMap> pixelMap = Media::PixelMap::Create(colors, colorLen, opts);
372     if (pixelMap == nullptr) {
373         delete[] colors;
374         FI_HILOGE("Create pixelMap failed");
375         return nullptr;
376     }
377     delete[] colors;
378     return pixelMap;
379 }
380 
CreateDragData(const std::pair<int32_t, int32_t> &pixelMapSize, int32_t sourceType, int32_t pointerId, int32_t displayId, const std::pair<int32_t, int32_t> &location)381 std::optional<DragData> InteractionManagerTest::CreateDragData(const std::pair<int32_t, int32_t> &pixelMapSize,
382     int32_t sourceType, int32_t pointerId, int32_t displayId, const std::pair<int32_t, int32_t> &location)
383 {
384     CALL_DEBUG_ENTER;
385     std::shared_ptr<Media::PixelMap> pixelMap = CreatePixelMap(pixelMapSize.first, pixelMapSize.second);
386     if (pixelMap == nullptr) {
387         FI_HILOGE("Create pixelmap failed");
388         return std::nullopt;
389     }
390     ShadowInfo shadowInfo { pixelMap, 0, 0 };
391     DragData dragData;
392     dragData.shadowInfos.push_back(shadowInfo);
393     dragData.buffer = std::vector<uint8_t>(MAX_BUFFER_SIZE, 0);
394     dragData.udKey = UD_KEY;
395     dragData.sourceType = sourceType;
396     dragData.pointerId = pointerId;
397     dragData.dragNum = DRAG_NUM;
398     dragData.displayX = location.first;
399     dragData.displayY = location.second;
400     dragData.displayId = displayId;
401     dragData.hasCanceledAnimation = HAS_CANCELED_ANIMATION;
402     dragData.extraInfo = EXTRA_INFO;
403     dragData.filterInfo = FILTER_INFO;
404     dragData.mainWindow = SRC_MAIN_WINDOW;
405     return dragData;
406 }
407 
CreatePointerItem(int32_t pointerId, int32_t deviceId, const std::pair<int32_t, int32_t> &displayLocation, bool isPressed)408 MMI::PointerEvent::PointerItem InteractionManagerTest::CreatePointerItem(int32_t pointerId, int32_t deviceId,
409     const std::pair<int32_t, int32_t> &displayLocation, bool isPressed)
410 {
411     MMI::PointerEvent::PointerItem item;
412     item.SetPointerId(pointerId);
413     item.SetDeviceId(deviceId);
414     item.SetDisplayX(displayLocation.first);
415     item.SetDisplayY(displayLocation.second);
416     item.SetPressed(isPressed);
417     return item;
418 }
419 
SetupPointerEvent(const std::pair<int32_t, int32_t> &displayLocation, int32_t action, int32_t sourceType, int32_t pointerId, bool isPressed)420 std::shared_ptr<MMI::PointerEvent> InteractionManagerTest::SetupPointerEvent(const std::pair<int32_t, int32_t>
421     &displayLocation, int32_t action, int32_t sourceType, int32_t pointerId, bool isPressed)
422 {
423     CALL_DEBUG_ENTER;
424     auto pointerEvent = MMI::PointerEvent::Create();
425     CHKPP(pointerEvent);
426     pointerEvent->SetPointerAction(action);
427     pointerEvent->SetSourceType(sourceType);
428     pointerEvent->SetPointerId(pointerId);
429     MMI::PointerEvent::PointerItem curPointerItem;
430     if (sourceType == MMI::PointerEvent::SOURCE_TYPE_MOUSE) {
431         curPointerItem = CreatePointerItem(pointerId, g_deviceMouseId, displayLocation, isPressed);
432     } else if (sourceType == MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN) {
433         curPointerItem = CreatePointerItem(pointerId, g_deviceTouchId, displayLocation, isPressed);
434     } else {
435         FI_HILOGE("Unknow sourceType:%{public}d", sourceType);
436         return nullptr;
437     }
438     pointerEvent->AddPointerItem(curPointerItem);
439     return pointerEvent;
440 }
441 
SimulateDownPointerEvent(const std::pair<int32_t, int32_t> &location, int32_t sourceType, int32_t pointerId)442 void InteractionManagerTest::SimulateDownPointerEvent(const std::pair<int32_t, int32_t> &location, int32_t sourceType,
443     int32_t pointerId)
444 {
445     CALL_DEBUG_ENTER;
446     SetPermission(SYSTEM_CORE, g_coresInject, sizeof(g_coresInject) / sizeof(g_coresInject[0]));
447     std::shared_ptr<MMI::PointerEvent> pointerEvent =
448         SetupPointerEvent(location, MMI::PointerEvent::POINTER_ACTION_DOWN, sourceType, pointerId, true);
449     CHKPV(pointerEvent);
450     FI_HILOGD("TEST:sourceType:%{public}d, pointerId:%{public}d, pointerAction:%{public}d",
451         pointerEvent->GetSourceType(), pointerEvent->GetPointerId(), pointerEvent->GetPointerAction());
452     MMI::InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
453     RemovePermission();
454 }
455 
SimulateUpPointerEvent(const std::pair<int32_t, int32_t> &location, int32_t sourceType, int32_t pointerId)456 void InteractionManagerTest::SimulateUpPointerEvent(const std::pair<int32_t, int32_t> &location, int32_t sourceType,
457     int32_t pointerId)
458 {
459     CALL_DEBUG_ENTER;
460     SetPermission(SYSTEM_CORE, g_coresInject, sizeof(g_coresInject) / sizeof(g_coresInject[0]));
461     std::shared_ptr<MMI::PointerEvent> pointerEvent = SetupPointerEvent(location,
462         MMI::PointerEvent::POINTER_ACTION_UP, sourceType, pointerId, false);
463     CHKPV(pointerEvent);
464     FI_HILOGD("TEST:sourceType:%{public}d, pointerId:%{public}d, pointerAction:%{public}d",
465         pointerEvent->GetSourceType(), pointerEvent->GetPointerId(), pointerEvent->GetPointerAction());
466     MMI::InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
467     RemovePermission();
468 }
469 
SimulateMovePointerEvent(const std::pair<int32_t, int32_t> &srcLocation, const std::pair<int32_t, int32_t> &dstLocation, int32_t sourceType, int32_t pointerId, bool isPressed)470 void InteractionManagerTest::SimulateMovePointerEvent(const std::pair<int32_t, int32_t> &srcLocation,
471     const std::pair<int32_t, int32_t> &dstLocation, int32_t sourceType, int32_t pointerId, bool isPressed)
472 {
473     CALL_DEBUG_ENTER;
474     SetPermission(SYSTEM_CORE, g_coresInject, sizeof(g_coresInject) / sizeof(g_coresInject[0]));
475     int32_t srcX = srcLocation.first;
476     int32_t srcY = srcLocation.second;
477     int32_t dstX = dstLocation.first;
478     int32_t dstY = dstLocation.second;
479     std::vector<std::pair<int32_t, int32_t>> coordinates;
480     if (dstX == srcX) {
481         for (int32_t y = srcY; y <= dstY; y += MOVE_STEP) {
482             coordinates.push_back({srcX, y});
483         }
484         for (int32_t y = srcY; y > dstY; y -= MOVE_STEP) {
485             coordinates.push_back({srcX, y});
486         }
487     } else {
488         double ratio = (dstY - srcY) * 1.0 / (dstX - srcX);
489         for (int32_t x = srcX; x < dstX; x += MOVE_STEP) {
490             coordinates.push_back({x, srcY + static_cast<int32_t>(ratio * (x - srcX))});
491         }
492         for (int32_t x = srcX; x >= dstX; x -= MOVE_STEP) {
493             coordinates.push_back({x, srcY + static_cast<int32_t>(ratio * (x - srcX))});
494         }
495         coordinates.push_back({dstX, dstY});
496     }
497     for (const auto& pointer : coordinates) {
498         std::shared_ptr<MMI::PointerEvent> pointerEvent =
499             SetupPointerEvent(pointer, MMI::PointerEvent::POINTER_ACTION_MOVE, sourceType, pointerId, isPressed);
500         CHKPC(pointerEvent);
501         FI_HILOGD("TEST:sourceType:%{public}d, pointerId:%{public}d, pointerAction:%{public}d",
502             pointerEvent->GetSourceType(), pointerEvent->GetPointerId(), pointerEvent->GetPointerAction());
503         MMI::InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
504         std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_INJECT_MS));
505     }
506     RemovePermission();
507 }
508 
TestAddMonitor(std::shared_ptr<MMI::IInputEventConsumer> consumer)509 int32_t InteractionManagerTest::TestAddMonitor(std::shared_ptr<MMI::IInputEventConsumer> consumer)
510 {
511     CHKPR(consumer, RET_ERR);
512     return MMI::InputManager::GetInstance()->AddMonitor(consumer);
513 }
514 
TestRemoveMonitor(int32_t monitorId)515 void InteractionManagerTest::TestRemoveMonitor(int32_t monitorId)
516 {
517     MMI::InputManager::GetInstance()->RemoveMonitor(monitorId);
518 }
519 
PrintDragData(const DragData &dragData)520 void InteractionManagerTest::PrintDragData(const DragData &dragData)
521 {
522     CALL_DEBUG_ENTER;
523     for (const auto &shadowInfo : dragData.shadowInfos) {
524         CHKPV(shadowInfo.pixelMap);
525         FI_HILOGD("PixelFormat:%{public}d, PixelAlphaType:%{public}d, PixelAllocatorType:%{public}d,"
526             " PixelWidth:%{public}d, PixelHeight:%{public}d, shadowX:%{public}d, shadowY:%{public}d",
527             static_cast<int32_t>(shadowInfo.pixelMap->GetPixelFormat()),
528             static_cast<int32_t>(shadowInfo.pixelMap->GetAlphaType()),
529             static_cast<int32_t>(shadowInfo.pixelMap->GetAllocatorType()),
530             shadowInfo.pixelMap->GetWidth(), shadowInfo.pixelMap->GetHeight(), shadowInfo.x, shadowInfo.y);
531     }
532     FI_HILOGD("SourceType:%{public}d, pointerId:%{public}d, displayId:%{public}d, displayX:%{public}d,"
533         " displayY:%{public}d, dragNum:%{public}d, hasCanceledAnimation:%{public}d, udKey:%{public}s",
534         dragData.sourceType, dragData.pointerId, dragData.displayId, dragData.displayX, dragData.displayY,
535         dragData.dragNum, dragData.hasCanceledAnimation, dragData.udKey.substr(0, SUBSTR_UDKEY_LEN).c_str());
536 }
537 
SetupKeyEvent( int32_t action, int32_t key, bool isPressed)538 void InteractionManagerTest::SetupKeyEvent(
539     int32_t action, int32_t key, bool isPressed)
540 {
541     CALL_DEBUG_ENTER;
542     CHKPV(g_keyEvent);
543     MMI::KeyEvent::KeyItem keyItem;
544     keyItem.SetKeyCode(key);
545     keyItem.SetDeviceId(1);
546     keyItem.SetDownTime(DOWN_TIME);
547     g_keyEvent->SetKeyAction(action);
548     g_keyEvent->SetKeyCode(key);
549     if (action == MMI::KeyEvent::KEY_ACTION_DOWN) {
550         keyItem.SetPressed(isPressed);
551     } else if (action == MMI::KeyEvent::KEY_ACTION_UP) {
552         g_keyEvent->RemoveReleasedKeyItems(keyItem);
553     }
554     g_keyEvent->AddPressedKeyItems(keyItem);
555 }
556 
ClearUpKeyEvent()557 void InteractionManagerTest::ClearUpKeyEvent()
558 {
559     CALL_DEBUG_ENTER;
560     CHKPV(g_keyEvent);
561     for (const auto& iter : g_keyEvent->GetKeyItems()) {
562         if (!iter.IsPressed()) {
563             FI_HILOGD("TEST:Clean keyItem, keyCode:%{public}d", iter.GetKeyCode());
564             g_keyEvent->RemoveReleasedKeyItems(iter);
565             return;
566         }
567     }
568 }
569 
SimulateDownKeyEvent(int32_t key)570 void InteractionManagerTest::SimulateDownKeyEvent(int32_t key)
571 {
572     CALL_DEBUG_ENTER;
573     SetPermission(SYSTEM_CORE, g_coresInject, sizeof(g_coresInject) / sizeof(g_coresInject[0]));
574     SetupKeyEvent(MMI::KeyEvent::KEY_ACTION_DOWN, key, true);
575     FI_HILOGD("TEST:keyCode:%{public}d, keyAction: KEY_ACTION_DOWN", key);
576     MMI::InputManager::GetInstance()->SimulateInputEvent(g_keyEvent);
577     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_INJECT_MS));
578     RemovePermission();
579 }
580 
SimulateUpKeyEvent(int32_t key)581 void InteractionManagerTest::SimulateUpKeyEvent(int32_t key)
582 {
583     CALL_DEBUG_ENTER;
584     SetPermission(SYSTEM_CORE, g_coresInject, sizeof(g_coresInject) / sizeof(g_coresInject[0]));
585     SetupKeyEvent(MMI::KeyEvent::KEY_ACTION_UP, key, false);
586     FI_HILOGD("TEST:keyCode:%{public}d, keyAction: KEY_ACTION_UP", key);
587     MMI::InputManager::GetInstance()->SimulateInputEvent(g_keyEvent);
588     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_INJECT_MS));
589     RemovePermission();
590 }
591 
PrintDragAction(DragAction dragAction)592 void InteractionManagerTest::PrintDragAction(DragAction dragAction)
593 {
594     switch (dragAction) {
595         case DragAction::MOVE:{
596             FI_HILOGD("drag action: MOVE");
597             break;
598         }
599         case DragAction::COPY:{
600             FI_HILOGD("drag action: COPY");
601             break;
602         }
603         default:{
604             FI_HILOGD("drag action: UNKNOWN");
605             break;
606         }
607     }
608 }
609 
AssignToAnimation(PreviewAnimation &animation)610 void InteractionManagerTest::AssignToAnimation(PreviewAnimation &animation)
611 {
612     animation.duration = ANIMATION_DURATION;
613     animation.curveName = CURVE_NAME;
614     animation.curve = { 0.33, 0, 0.67, 1 };
615 }
616 
617 class InputEventCallbackTest : public MMI::IInputEventConsumer {
618 public:
InputEventCallbackTest()619     InputEventCallbackTest() {}
InputEventCallbackTest(std::function<void()> callback)620     explicit InputEventCallbackTest(std::function<void()> callback) : callback_(callback) {}
621     void OnInputEvent(std::shared_ptr<MMI::KeyEvent> keyEvent) const override {};
622     void OnInputEvent(std::shared_ptr<MMI::PointerEvent> pointerEvent) const override;
623     void OnInputEvent(std::shared_ptr<MMI::AxisEvent> axisEvent) const override {};
624 private:
625     std::function<void()> callback_ { nullptr };
626 };
627 
OnInputEvent(std::shared_ptr<MMI::PointerEvent> pointerEvent) const628 void InputEventCallbackTest::OnInputEvent(std::shared_ptr<MMI::PointerEvent> pointerEvent) const
629 {
630     CALL_DEBUG_ENTER;
631     ASSERT_TRUE(pointerEvent != nullptr);
632     auto pointerAction = pointerEvent->GetPointerAction();
633     ASSERT_TRUE(pointerAction == MMI::PointerEvent::POINTER_ACTION_PULL_MOVE ||
634                 pointerAction == MMI::PointerEvent::POINTER_ACTION_PULL_UP ||
635                 pointerAction == MMI::PointerEvent::POINTER_ACTION_PULL_IN_WINDOW ||
636                 pointerAction == MMI::PointerEvent::POINTER_ACTION_PULL_OUT_WINDOW);
637     ASSERT_TRUE(!pointerEvent->GetBuffer().empty());
638     MMI::PointerEvent::PointerItem pointerItem;
639     pointerEvent->GetPointerItem(pointerEvent->GetPointerId(), pointerItem);
640     if (callback_ != nullptr && pointerItem.GetDisplayX() == DRAG_DST_X && pointerItem.GetDisplayY() == DRAG_DST_Y) {
641         callback_();
642     }
643 }
644 
645 /**
646  * @tc.name: InteractionManagerTest_PrepareCoordination
647  * @tc.desc: Prepare coordination
648  * @tc.type: FUNC
649  * @tc.require:
650  */
HWTEST_F(InteractionManagerTest, InteractionManagerTest_PrepareCoordination, TestSize.Level1)651 HWTEST_F(InteractionManagerTest, InteractionManagerTest_PrepareCoordination, TestSize.Level1)
652 {
653     CALL_TEST_DEBUG;
654     SetPermission(SYSTEM_BASIC, g_basics, sizeof(g_basics) / sizeof(g_basics[0]));
655     std::promise<bool> promiseFlag;
656     std::future<bool> futureFlag = promiseFlag.get_future();
657     auto fun = [&promiseFlag](const std::string &listener, const CoordinationMsgInfo &coordinationMessages) {
658         FI_HILOGD("Prepare coordination success, listener:%{public}s", listener.c_str());
659         promiseFlag.set_value(true);
660     };
661     bool isCompatible = true;
662     int32_t ret = InteractionManager::GetInstance()->PrepareCoordination(fun, isCompatible);
663 #ifdef OHOS_BUILD_ENABLE_COORDINATION
664     ASSERT_EQ(ret, RET_OK);
665     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) != std::future_status::timeout);
666 #else
667     ASSERT_EQ(ret, ERROR_UNSUPPORT);
668 #endif // OHOS_BUILD_ENABLE_COORDINATION
669     RemovePermission();
670 }
671 
672 /**
673  * @tc.name: InteractionManagerTest_RegisterCoordinationListener_001
674  * @tc.desc: Register coordination listener
675  * @tc.type: FUNC
676  * @tc.require:
677  */
HWTEST_F(InteractionManagerTest, InteractionManagerTest_RegisterCoordinationListener_001, TestSize.Level1)678 HWTEST_F(InteractionManagerTest, InteractionManagerTest_RegisterCoordinationListener_001, TestSize.Level1)
679 {
680     CALL_TEST_DEBUG;
681     SetPermission(SYSTEM_BASIC, g_basics, sizeof(g_basics) / sizeof(g_basics[0]));
682     std::shared_ptr<ICoordinationListener> consumer = nullptr;
683     bool isCompatible = true;
684     int32_t ret = InteractionManager::GetInstance()->RegisterCoordinationListener(consumer, isCompatible);
685 #ifdef OHOS_BUILD_ENABLE_COORDINATION
686     ASSERT_EQ(ret, RET_ERR);
687 #else
688     ASSERT_EQ(ret, ERROR_UNSUPPORT);
689 #endif // OHOS_BUILD_ENABLE_COORDINATION
690     RemovePermission();
691 }
692 
693 /**
694  * @tc.name: InteractionManagerTest_RegisterCoordinationListener_002
695  * @tc.desc: Register coordination listener
696  * @tc.type: FUNC
697  * @tc.require:
698  */
HWTEST_F(InteractionManagerTest, InteractionManagerTest_RegisterCoordinationListener_002, TestSize.Level1)699 HWTEST_F(InteractionManagerTest, InteractionManagerTest_RegisterCoordinationListener_002, TestSize.Level1)
700 {
701     CALL_DEBUG_ENTER;
702     SetPermission(SYSTEM_BASIC, g_basics, sizeof(g_basics) / sizeof(g_basics[0]));
703     class CoordinationListenerTest : public ICoordinationListener {
704     public:
705         CoordinationListenerTest() : ICoordinationListener() {}
706         void OnCoordinationMessage(const std::string &networkId, CoordinationMessage msg) override
707         {
708             FI_HILOGD("Register coordination listener test");
709             (void) networkId;
710         };
711     };
712     std::shared_ptr<CoordinationListenerTest> consumer =
713         std::make_shared<CoordinationListenerTest>();
714     bool isCompatible = true;
715     int32_t ret = InteractionManager::GetInstance()->RegisterCoordinationListener(consumer, isCompatible);
716 #ifdef OHOS_BUILD_ENABLE_COORDINATION
717     ASSERT_EQ(ret, RET_OK);
718 #else
719     ASSERT_EQ(ret, ERROR_UNSUPPORT);
720 #endif // OHOS_BUILD_ENABLE_COORDINATION
721     ret = InteractionManager::GetInstance()->UnregisterCoordinationListener(consumer, isCompatible);
722 #ifdef OHOS_BUILD_ENABLE_COORDINATION
723     ASSERT_EQ(ret, RET_OK);
724 #else
725     ASSERT_EQ(ret, ERROR_UNSUPPORT);
726 #endif // OHOS_BUILD_ENABLE_COORDINATION
727     RemovePermission();
728 }
729 
730 /**
731  * @tc.name: InteractionManagerTest_RegisterCoordinationListener_003
732  * @tc.desc: Register coordination listener
733  * @tc.type: FUNC
734  * @tc.require:
735  */
HWTEST_F(InteractionManagerTest, InteractionManagerTest_RegisterCoordinationListener_003, TestSize.Level1)736 HWTEST_F(InteractionManagerTest, InteractionManagerTest_RegisterCoordinationListener_003, TestSize.Level1)
737 {
738     CALL_TEST_DEBUG;
739     FI_HILOGD("InteractionManagerTest_RegisterCoordinationListener_003 enter");
740     SetPermission(SYSTEM_BASIC, g_basics, sizeof(g_basics) / sizeof(g_basics[0]));
741     class CoordinationListenerTest : public ICoordinationListener {
742     public:
743         CoordinationListenerTest() : ICoordinationListener() {}
744         void OnCoordinationMessage(const std::string &networkId, CoordinationMessage msg) override
745         {
746             FI_HILOGD("Register coordination listener test");
747             (void) networkId;
748         };
749     };
750     std::shared_ptr<CoordinationListenerTest> consumer =
751         std::make_shared<CoordinationListenerTest>();
752     bool isCompatible = true;
753     int32_t ret = InteractionManager::GetInstance()->RegisterCoordinationListener(consumer, isCompatible);
754     #ifdef OHOS_BUILD_ENABLE_COORDINATION
755         ASSERT_EQ(ret, RET_OK);
756     #else
757         ASSERT_EQ(ret, ERROR_UNSUPPORT);
758     #endif // OHOS_BUILD_ENABLE_COORDINATION
759         ret = InteractionManager::GetInstance()->RegisterCoordinationListener(consumer, isCompatible);
760     #ifdef OHOS_BUILD_ENABLE_COORDINATION
761         ASSERT_EQ(ret, RET_ERR);
762     #else
763         ASSERT_EQ(ret, ERROR_UNSUPPORT);
764     #endif // OHOS_BUILD_ENABLE_COORDINATION
765         ret = InteractionManager::GetInstance()->UnregisterCoordinationListener(consumer, isCompatible);
766     #ifdef OHOS_BUILD_ENABLE_COORDINATION
767         ASSERT_EQ(ret, RET_OK);
768     #else
769         ASSERT_EQ(ret, ERROR_UNSUPPORT);
770     #endif // OHOS_BUILD_ENABLE_COORDINATION
771     RemovePermission();
772     FI_HILOGD("InteractionManagerTest_RegisterCoordinationListener_003 finish");
773 }
774 
775 /**
776  * @tc.name: InteractionManagerTest_ActivateCoordination
777  * @tc.desc: Activate coordination
778  * @tc.type: FUNC
779  * @tc.require:
780  */
HWTEST_F(InteractionManagerTest, InteractionManagerTest_ActivateCoordination, TestSize.Level1)781 HWTEST_F(InteractionManagerTest, InteractionManagerTest_ActivateCoordination, TestSize.Level1)
782 {
783     CALL_TEST_DEBUG;
784     SetPermission(SYSTEM_BASIC, g_basics, sizeof(g_basics) / sizeof(g_basics[0]));
785     std::string remoteNetworkId("");
786     int32_t startDeviceId = -1;
787     auto fun = [](const std::string &listener, const CoordinationMsgInfo &coordinationMessages) {
788         FI_HILOGD("Start coordination success");
789         (void) listener;
790     };
791     bool isCompatible = true;
792     int32_t ret = InteractionManager::GetInstance()->ActivateCoordination(remoteNetworkId, startDeviceId,
793         fun, isCompatible);
794 #ifdef OHOS_BUILD_ENABLE_COORDINATION
795     ASSERT_TRUE((ret == RET_OK || ret == COMMON_PERMISSION_CHECK_ERROR || ret == COMMON_NOT_ALLOWED_DISTRIBUTED));
796 #else
797     ASSERT_EQ(ret, ERROR_UNSUPPORT);
798 #endif // OHOS_BUILD_ENABLE_COORDINATION
799     RemovePermission();
800 }
801 
802 /**
803  * @tc.name: InteractionManagerTest_DeactivateCoordination
804  * @tc.desc: Deactivate coordination
805  * @tc.type: FUNC
806  * @tc.require:
807  */
HWTEST_F(InteractionManagerTest, InteractionManagerTest_DeactivateCoordination, TestSize.Level1)808 HWTEST_F(InteractionManagerTest, InteractionManagerTest_DeactivateCoordination, TestSize.Level1)
809 {
810     CALL_TEST_DEBUG;
811     SetPermission(SYSTEM_BASIC, g_basics, sizeof(g_basics) / sizeof(g_basics[0]));
812     auto fun = [](const std::string &listener, const CoordinationMsgInfo &coordinationMessages) {
813         FI_HILOGD("Stop coordination success");
814         (void) listener;
815     };
816     bool isCompatible = true;
817     int32_t ret = InteractionManager::GetInstance()->DeactivateCoordination(false, fun, isCompatible);
818 #ifdef OHOS_BUILD_ENABLE_COORDINATION
819     ASSERT_EQ(ret, RET_OK);
820 #else
821     ASSERT_EQ(ret, ERROR_UNSUPPORT);
822     ret = InteractionManager::GetInstance()->DeactivateCoordination(true, fun, isCompatible);
823     ASSERT_EQ(ret, ERROR_UNSUPPORT);
824 #endif // OHOS_BUILD_ENABLE_COORDINATION
825     RemovePermission();
826 }
827 
828 /**
829  * @tc.name: InteractionManagerTest_GetCoordinationState_Abnormal
830  * @tc.desc: Get coordination state
831  * @tc.type: FUNC
832  * @tc.require:
833  */
HWTEST_F(InteractionManagerTest, InteractionManagerTest_GetCoordinationState_Abnormal, TestSize.Level1)834 HWTEST_F(InteractionManagerTest, InteractionManagerTest_GetCoordinationState_Abnormal, TestSize.Level1)
835 {
836     CALL_TEST_DEBUG;
837     SetPermission(SYSTEM_BASIC, g_basics, sizeof(g_basics) / sizeof(g_basics[0]));
838     const std::string networkId("");
839     auto fun = [](bool state) {
840         FI_HILOGD("Get coordination state failed, state:%{public}d", state);
841     };
842     bool isCompatible = true;
843     int32_t ret = InteractionManager::GetInstance()->GetCoordinationState(networkId, fun, isCompatible);
844 #ifdef OHOS_BUILD_ENABLE_COORDINATION
845     ASSERT_EQ(ret, RET_OK);
846 #else
847     ASSERT_EQ(ret, ERROR_UNSUPPORT);
848 #endif // OHOS_BUILD_ENABLE_COORDINATION
849     RemovePermission();
850 }
851 
852 /**
853  * @tc.name: InteractionManagerTest_GetCoordinationState_Normal
854  * @tc.desc: Get coordination state
855  * @tc.type: FUNC
856  * @tc.require:
857  */
HWTEST_F(InteractionManagerTest, InteractionManagerTest_GetCoordinationState_Normal, TestSize.Level1)858 HWTEST_F(InteractionManagerTest, InteractionManagerTest_GetCoordinationState_Normal, TestSize.Level1)
859 {
860     CALL_TEST_DEBUG;
861     SetPermission(SYSTEM_BASIC, g_basics, sizeof(g_basics) / sizeof(g_basics[0]));
862     std::promise<bool> promiseFlag;
863     std::future<bool> futureFlag = promiseFlag.get_future();
864     const std::string networkId("networkId");
865     auto fun = [&promiseFlag](bool state) {
866         FI_HILOGD("Get coordination state success, state:%{public}d", state);
867         promiseFlag.set_value(true);
868     };
869     bool isCompatible = true;
870     int32_t ret = InteractionManager::GetInstance()->GetCoordinationState(networkId, fun, isCompatible);
871 #ifdef OHOS_BUILD_ENABLE_COORDINATION
872     ASSERT_EQ(ret, RET_OK);
873     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) != std::future_status::timeout);
874 #else
875     ASSERT_EQ(ret, ERROR_UNSUPPORT);
876 #endif // OHOS_BUILD_ENABLE_COORDINATION
877     RemovePermission();
878 }
879 
880 /**
881  * @tc.name: InteractionManagerTest_GetCoordinationState_Sync
882  * @tc.desc: Get coordination state
883  * @tc.type: FUNC
884  * @tc.require:
885  */
HWTEST_F(InteractionManagerTest, InteractionManagerTest_GetCoordinationState_Sync, TestSize.Level1)886 HWTEST_F(InteractionManagerTest, InteractionManagerTest_GetCoordinationState_Sync, TestSize.Level1)
887 {
888     CALL_TEST_DEBUG;
889     SetPermission(SYSTEM_BASIC, g_basics, sizeof(g_basics) / sizeof(g_basics[0]));
890     const std::string udId("Default");
891     bool state { false };
892     int32_t ret = InteractionManager::GetInstance()->GetCoordinationState(udId, state);
893 #ifdef OHOS_BUILD_ENABLE_COORDINATION
894     ASSERT_EQ(ret, RET_OK);
895 #else
896     ASSERT_EQ(ret, ERROR_UNSUPPORT);
897 #endif // OHOS_BUILD_ENABLE_COORDINATION
898     RemovePermission();
899 }
900 
901 /**
902  * @tc.name: InteractionManagerTest_UnregisterCoordinationListener
903  * @tc.desc: Unregister coordination listener
904  * @tc.type: FUNC
905  * @tc.require:
906  */
HWTEST_F(InteractionManagerTest, InteractionManagerTest_UnregisterCoordinationListener, TestSize.Level1)907 HWTEST_F(InteractionManagerTest, InteractionManagerTest_UnregisterCoordinationListener, TestSize.Level1)
908 {
909     CALL_TEST_DEBUG;
910     SetPermission(SYSTEM_BASIC, g_basics, sizeof(g_basics) / sizeof(g_basics[0]));
911     std::shared_ptr<ICoordinationListener> consumer = nullptr;
912     bool isCompatible = true;
913     int32_t ret = InteractionManager::GetInstance()->UnregisterCoordinationListener(consumer, isCompatible);
914 #ifdef OHOS_BUILD_ENABLE_COORDINATION
915     ASSERT_EQ(ret, RET_OK);
916 #else
917     ASSERT_EQ(ret, ERROR_UNSUPPORT);
918 #endif // OHOS_BUILD_ENABLE_COORDINATION
919     RemovePermission();
920 }
921 
922 /**
923  * @tc.name: InteractionManagerTest_UnprepareCoordination
924  * @tc.desc: Prepare coordination
925  * @tc.type: FUNC
926  * @tc.require:
927  */
HWTEST_F(InteractionManagerTest, InteractionManagerTest_UnprepareCoordination, TestSize.Level1)928 HWTEST_F(InteractionManagerTest, InteractionManagerTest_UnprepareCoordination, TestSize.Level1)
929 {
930     CALL_TEST_DEBUG;
931     SetPermission(SYSTEM_BASIC, g_basics, sizeof(g_basics) / sizeof(g_basics[0]));
932     std::promise<bool> promiseFlag;
933     std::future<bool> futureFlag = promiseFlag.get_future();
934     auto fun = [&promiseFlag](const std::string &listener, const CoordinationMsgInfo &coordinationMessages) {
935         FI_HILOGD("Prepare coordination success, listener:%{public}s", listener.c_str());
936         promiseFlag.set_value(true);
937     };
938     bool isCompatible = true;
939     int32_t ret = InteractionManager::GetInstance()->UnprepareCoordination(fun, isCompatible);
940 #ifdef OHOS_BUILD_ENABLE_COORDINATION
941     ASSERT_EQ(ret, RET_OK);
942     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) != std::future_status::timeout);
943 #else
944     ASSERT_EQ(ret, ERROR_UNSUPPORT);
945 #endif // OHOS_BUILD_ENABLE_COORDINATION
946     RemovePermission();
947 }
948 
949 
950 class HotAreaListenerTest : public IHotAreaListener {
951 public:
HotAreaListenerTest()952     HotAreaListenerTest() {}
HotAreaListenerTest(std::string name)953     explicit HotAreaListenerTest(std::string name) : testName_(name) {}
954     void OnHotAreaMessage(int32_t displayX, int32_t displayY, HotAreaType msg, bool isEdge) override
955     {
956         if (testName_.empty()) {
957             testName_ = std::string("HOT_AREA");
958         }
959         FI_HILOGD("%{public}s, type:%{public}s, isEdge:%{public}d, displayX:%{public}d, displayY:%{public}d",
960             testName_.c_str(), ShowMessage(msg).c_str(), isEdge, displayX, displayY);
961     };
962 
963 private:
ShowMessage(HotAreaType msg)964     std::string ShowMessage(HotAreaType msg)
965     {
966         std::string type = "none-area";
967         const std::map<HotAreaType, std::string> areaType = {
968             { HotAreaType::AREA_LEFT, "left-area"},
969             { HotAreaType::AREA_RIGHT, "right-area"},
970             { HotAreaType::AREA_TOP, "top-area"},
971             { HotAreaType::AREA_BOTTOM, "bottom-area"}
972         };
973         auto item = areaType.find(msg);
974         if (item != areaType.end()) {
975             type = item->second;
976         }
977         return type;
978     }
979 
980 private:
981     std::string testName_;
982 };
983 
984 /**
985  * @tc.name: AddHotAreaListener_001
986  * @tc.desc: Add hot area listener
987  * @tc.type: FUNC
988  * @tc.require:
989  */
HWTEST_F(InteractionManagerTest, AddHotAreaListener_001, TestSize.Level1)990 HWTEST_F(InteractionManagerTest, AddHotAreaListener_001, TestSize.Level1)
991 {
992     CALL_TEST_DEBUG;
993     SetPermission(SYSTEM_BASIC, g_basics, sizeof(g_basics) / sizeof(g_basics[0]));
994     auto listener = std::make_shared<HotAreaListenerTest>(std::string("HOT_AREA"));
995     int32_t ret = InteractionManager::GetInstance()->AddHotAreaListener(listener);
996 #ifdef OHOS_BUILD_ENABLE_COORDINATION
997     ASSERT_EQ(ret, RET_OK);
998 #else
999     ASSERT_EQ(ret, ERROR_UNSUPPORT);
1000 #endif // OHOS_BUILD_ENABLE_COORDINATION
1001     ret = InteractionManager::GetInstance()->RemoveHotAreaListener(listener);
1002 #ifdef OHOS_BUILD_ENABLE_COORDINATION
1003     ASSERT_EQ(ret, RET_OK);
1004 #else
1005     ASSERT_EQ(ret, ERROR_UNSUPPORT);
1006 #endif // OHOS_BUILD_ENABLE_COORDINATION
1007     RemovePermission();
1008 }
1009 
1010 /**
1011  * @tc.name: AddHotAreaListener_002
1012  * @tc.desc: Add hot area listener
1013  * @tc.type: FUNC
1014  * @tc.require:
1015  */
HWTEST_F(InteractionManagerTest, AddHotAreaListener_002, TestSize.Level1)1016 HWTEST_F(InteractionManagerTest, AddHotAreaListener_002, TestSize.Level1)
1017 {
1018     CALL_DEBUG_ENTER;
1019     SetPermission(SYSTEM_BASIC, g_basics, sizeof(g_basics) / sizeof(g_basics[0]));
1020     sptr<Rosen::Display> display = Rosen::DisplayManager::GetInstance().GetDisplayById(0);
1021     CHKPV(display);
1022     g_screenWidth = display->GetWidth();
1023     g_screenHeight = display->GetHeight();
1024     auto listener = std::make_shared<HotAreaListenerTest>(std::string("HOT_AREA"));
1025     int32_t ret = InteractionManager::GetInstance()->AddHotAreaListener(listener);
1026 #ifdef OHOS_BUILD_ENABLE_COORDINATION
1027     ASSERT_EQ(ret, RET_OK);
1028 #else
1029     ASSERT_EQ(ret, ERROR_UNSUPPORT);
1030 #endif // OHOS_BUILD_ENABLE_COORDINATION
1031     SimulateMovePointerEvent({ HOT_AREA_STEP, HOT_AREA_COOR }, { HOT_AREA_STEP - HOT_AREA_SPAN, HOT_AREA_COOR },
1032         MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, true);
1033     SimulateMovePointerEvent({ HOT_AREA_COOR, HOT_AREA_STEP }, { HOT_AREA_COOR, HOT_AREA_STEP - HOT_AREA_SPAN },
1034         MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, true);
1035     SimulateMovePointerEvent({ g_screenWidth - HOT_AREA_STEP, HOT_AREA_COOR },
1036         { g_screenWidth - HOT_AREA_SPAN, HOT_AREA_COOR },
1037         MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, true);
1038     SimulateMovePointerEvent({ HOT_AREA_COOR, g_screenHeight - HOT_AREA_STEP },
1039         { HOT_AREA_COOR, g_screenHeight - HOT_AREA_SPAN },
1040         MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, true);
1041     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_TOUCH_DOWN_MS));
1042     SetPermission(SYSTEM_BASIC, g_basics, sizeof(g_basics) / sizeof(g_basics[0]));
1043     ret = InteractionManager::GetInstance()->RemoveHotAreaListener(listener);
1044 #ifdef OHOS_BUILD_ENABLE_COORDINATION
1045     ASSERT_EQ(ret, RET_OK);
1046 #else
1047     ASSERT_EQ(ret, ERROR_UNSUPPORT);
1048 #endif // OHOS_BUILD_ENABLE_COORDINATION
1049     RemovePermission();
1050 }
1051 
1052 /**
1053  * @tc.name: Set
1054  * @tc.desc: Set dampling coefficient.
1055  * @tc.type: FUNC
1056  * @tc.require:
1057  */
HWTEST_F(InteractionManagerTest, InteractionManagerTest_SetDamplingCoefficient, TestSize.Level1)1058 HWTEST_F(InteractionManagerTest, InteractionManagerTest_SetDamplingCoefficient, TestSize.Level1)
1059 {
1060     CALL_TEST_DEBUG;
1061     SetPermission(SYSTEM_BASIC, g_basics, sizeof(g_basics) / sizeof(g_basics[0]));
1062     constexpr double damplingCoefficient { 0.1 };
1063     auto ret = InteractionManager::GetInstance()->SetDamplingCoefficient(
1064         COORDINATION_DAMPLING_RIGHT, damplingCoefficient);
1065     ASSERT_EQ(ret, RET_OK);
1066 }
1067 
1068 /**
1069  * @tc.name: InteractionManagerTest_Draglistener_Mouse
1070  * @tc.desc: Drag listener
1071  * @tc.type: FUNC
1072  * @tc.require:
1073  */
HWTEST_F(InteractionManagerTest, InteractionManagerTest_Draglistener_Mouse, TestSize.Level1)1074 HWTEST_F(InteractionManagerTest, InteractionManagerTest_Draglistener_Mouse, TestSize.Level1)
1075 {
1076     CALL_TEST_DEBUG;
1077     if (g_deviceMouseId < 0) {
1078         ASSERT_TRUE(g_deviceMouseId < 0);
1079     } else {
1080         auto listener = std::make_shared<DragListenerTest>(std::string("Draglistener_Mouse"));
1081         int32_t ret = InteractionManager::GetInstance()->AddDraglistener(listener);
1082         ASSERT_EQ(ret, RET_OK);
1083         std::promise<bool> promiseFlag;
1084         std::future<bool> futureFlag = promiseFlag.get_future();
1085         auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
1086             FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
1087                 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
1088             promiseFlag.set_value(true);
1089         };
1090         SimulateDownPointerEvent(
1091             { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID);
1092         std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
1093             MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
1094         ASSERT_TRUE(dragData);
1095         ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1096             std::make_shared<UnitTestStartDragListener>(callback));
1097         ASSERT_EQ(ret, RET_OK);
1098         ret = InteractionManager::GetInstance()->SetDragWindowVisible(true);
1099         EXPECT_EQ(ret, RET_OK);
1100         SimulateMovePointerEvent({ DRAG_SRC_X, DRAG_SRC_Y }, { DRAG_DST_X, DRAG_DST_Y },
1101             MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, true);
1102         DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
1103         InteractionManager::GetInstance()->StopDrag(dropResult);
1104         ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
1105             std::future_status::timeout);
1106         ret = InteractionManager::GetInstance()->RemoveDraglistener(listener);
1107         ASSERT_EQ(ret, RET_OK);
1108     }
1109 }
1110 
1111 /**
1112  * @tc.name: InteractionManagerTest_Draglistener_Touch
1113  * @tc.desc: Drag listener
1114  * @tc.type: FUNC
1115  * @tc.require:
1116  */
HWTEST_F(InteractionManagerTest, InteractionManagerTest_Draglistener_Touch, TestSize.Level1)1117 HWTEST_F(InteractionManagerTest, InteractionManagerTest_Draglistener_Touch, TestSize.Level1)
1118 {
1119     CALL_TEST_DEBUG;
1120     if (g_deviceTouchId < 0) {
1121         ASSERT_TRUE(g_deviceTouchId < 0);
1122     } else {
1123         auto dragListener = std::make_shared<DragListenerTest>(std::string("Draglistener_Touch"));
1124         int32_t ret = InteractionManager::GetInstance()->AddDraglistener(dragListener);
1125         ASSERT_EQ(ret, RET_OK);
1126         std::promise<bool> promiseFlag;
1127         std::future<bool> futureFlag = promiseFlag.get_future();
1128         auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
1129             FI_HILOGD("displayX:%{public}d, displayY:%{public}d, target:%{public}d, result:%{public}d",
1130                 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.targetPid, notifyMessage.result);
1131             promiseFlag.set_value(true);
1132         };
1133         SimulateDownPointerEvent(
1134             { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID);
1135         std::optional<DragData> dragData = CreateDragData({ MAX_PIXEL_MAP_WIDTH, MAX_PIXEL_MAP_HEIGHT },
1136             MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
1137         ASSERT_TRUE(dragData);
1138         ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1139             std::make_shared<UnitTestStartDragListener>(callback));
1140         ASSERT_EQ(ret, RET_OK);
1141         SimulateMovePointerEvent({ DRAG_SRC_X, DRAG_SRC_Y }, { DRAG_DST_X, DRAG_DST_Y },
1142             MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, true);
1143         DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
1144         InteractionManager::GetInstance()->StopDrag(dropResult);
1145         ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
1146             std::future_status::timeout);
1147         ret = InteractionManager::GetInstance()->RemoveDraglistener(dragListener);
1148         ASSERT_EQ(ret, RET_OK);
1149     }
1150 }
1151 
1152 /**
1153  * @tc.name: InteractionManagerTest_Draglistener
1154  * @tc.desc: Drag listener
1155  * @tc.type: FUNC
1156  * @tc.require:
1157  */
HWTEST_F(InteractionManagerTest, InteractionManagerTest_Draglistener, TestSize.Level1)1158 HWTEST_F(InteractionManagerTest, InteractionManagerTest_Draglistener, TestSize.Level1)
1159 {
1160     CALL_TEST_DEBUG;
1161     if (g_deviceTouchId < 0) {
1162         ASSERT_TRUE(g_deviceTouchId < 0);
1163     } else {
1164         int32_t ret = RET_ERR;
1165         std::vector<std::shared_ptr<DragListenerTest>> dragListeners;
1166         constexpr size_t listenerCount = 5;
1167         for (size_t i = 0; i < listenerCount; ++i) {
1168             std::string moduleName = "Draglistener_" + std::to_string(i);
1169             auto listener = std::make_shared<DragListenerTest>(moduleName);
1170             ret = InteractionManager::GetInstance()->AddDraglistener(listener);
1171             if (ret == RET_OK) {
1172                 dragListeners.push_back(listener);
1173             }
1174         }
1175         SimulateDownPointerEvent(
1176             { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID);
1177         std::optional<DragData> dragData = CreateDragData({ MAX_PIXEL_MAP_WIDTH, MAX_PIXEL_MAP_HEIGHT },
1178             MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
1179         ASSERT_TRUE(dragData);
1180         std::promise<bool> promiseFlag;
1181         std::future<bool> futureFlag = promiseFlag.get_future();
1182         auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
1183             FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
1184                 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
1185             promiseFlag.set_value(true);
1186         };
1187         ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1188             std::make_shared<UnitTestStartDragListener>(callback));
1189         ASSERT_EQ(ret, RET_OK);
1190         SimulateMovePointerEvent({ DRAG_SRC_X, DRAG_SRC_Y }, { DRAG_DST_X, DRAG_DST_Y },
1191             MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, true);
1192         DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
1193         InteractionManager::GetInstance()->StopDrag(dropResult);
1194         ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
1195             std::future_status::timeout);
1196         for (const auto &listener : dragListeners) {
1197             ret = InteractionManager::GetInstance()->RemoveDraglistener(listener);
1198             EXPECT_EQ(ret, RET_OK);
1199         }
1200     }
1201 }
1202 
1203 /**
1204  * @tc.name: InteractionManagerTest_SubscriptListener_001
1205  * @tc.desc: SubscriptListener
1206  * @tc.type: FUNC
1207  * @tc.require:
1208  */
HWTEST_F(InteractionManagerTest, InteractionManagerTest_SubscriptListener_001, TestSize.Level1)1209 HWTEST_F(InteractionManagerTest, InteractionManagerTest_SubscriptListener_001, TestSize.Level1)
1210 {
1211     CALL_TEST_DEBUG;
1212     if (g_deviceTouchId < 0) {
1213         ASSERT_TRUE(g_deviceTouchId < 0);
1214     } else {
1215         int32_t ret = RET_ERR;
1216         std::vector<std::shared_ptr<SubscriptListenerTest>> subscriptListeners;
1217         for (size_t i = 0; i < RECIVE_LOOP_COUNT; ++i) {
1218             std::string moduleName = "SubscriptListener_" + std::to_string(i);
1219             auto listener = std::make_shared<SubscriptListenerTest>(moduleName);
1220             ret = InteractionManager::GetInstance()->AddSubscriptListener(listener);
1221             EXPECT_EQ(ret, RET_OK);
1222             subscriptListeners.push_back(listener);
1223         }
1224         std::promise<bool> promiseFlag;
1225         std::future<bool> futureFlag = promiseFlag.get_future();
1226         auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
1227             FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
1228                 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
1229             promiseFlag.set_value(true);
1230         };
1231         std::optional<DragData> dragData = CreateDragData({ MAX_PIXEL_MAP_WIDTH, MAX_PIXEL_MAP_HEIGHT },
1232             MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
1233         ASSERT_TRUE(dragData);
1234         ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1235             std::make_shared<UnitTestStartDragListener>(callback));
1236         ASSERT_EQ(ret, RET_OK);
1237         SimulateMovePointerEvent({ DRAG_SRC_X, DRAG_SRC_Y }, { DRAG_DST_X, DRAG_DST_Y },
1238             MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, true);
1239         DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
1240         InteractionManager::GetInstance()->StopDrag(dropResult);
1241         ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
1242             std::future_status::timeout);
1243         for (auto listener : subscriptListeners) {
1244             ret = InteractionManager::GetInstance()->RemoveSubscriptListener(listener);
1245             EXPECT_EQ(ret, RET_OK);
1246         }
1247     }
1248 }
1249 
1250 /**
1251  * @tc.name: InteractionManagerTest_SubscriptListener_002
1252  * @tc.desc: SubscriptListener
1253  * @tc.type: FUNC
1254  * @tc.require:
1255  */
HWTEST_F(InteractionManagerTest, InteractionManagerTest_SubscriptListener_002, TestSize.Level1)1256 HWTEST_F(InteractionManagerTest, InteractionManagerTest_SubscriptListener_002, TestSize.Level1)
1257 {
1258     CALL_TEST_DEBUG;
1259     if (g_deviceTouchId < 0) {
1260         ASSERT_TRUE(g_deviceTouchId < 0);
1261     } else {
1262         int32_t ret = RET_ERR;
1263         auto listener = std::make_shared<SubscriptListenerTest>("SubscriptListener");
1264         ret = InteractionManager::GetInstance()->AddSubscriptListener(listener);
1265         ASSERT_EQ(ret, RET_OK);
1266         std::promise<bool> promiseFlag;
1267         std::future<bool> futureFlag = promiseFlag.get_future();
1268         auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
1269             FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
1270                 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
1271             promiseFlag.set_value(true);
1272         };
1273         std::optional<DragData> dragData = CreateDragData({ MAX_PIXEL_MAP_WIDTH, MAX_PIXEL_MAP_HEIGHT },
1274             MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
1275         ASSERT_TRUE(dragData);
1276         ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1277             std::make_shared<UnitTestStartDragListener>(callback));
1278         ASSERT_EQ(ret, RET_OK);
1279         ret = InteractionManager::GetInstance()->SetDragWindowVisible(true);
1280         ASSERT_EQ(ret, RET_OK);
1281         DragCursorStyle style = DragCursorStyle::COPY;
1282         ret = InteractionManager::GetInstance()->UpdateDragStyle(style);
1283         ASSERT_EQ(ret, RET_OK);
1284         style = DragCursorStyle::MOVE;
1285         ret = InteractionManager::GetInstance()->UpdateDragStyle(style);
1286         ASSERT_EQ(ret, RET_OK);
1287         SimulateMovePointerEvent({ DRAG_SRC_X, DRAG_SRC_Y }, { DRAG_DST_X, DRAG_DST_Y },
1288             MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, true);
1289         DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
1290         InteractionManager::GetInstance()->StopDrag(dropResult);
1291         ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
1292             std::future_status::timeout);
1293         DragCursorStyle recvStyle = listener->GetDragStyle();
1294         FI_HILOGD("Recived style:%{public}d, expected style:%{public}d", static_cast<int32_t>(recvStyle),
1295             static_cast<int32_t>(style));
1296         ret = InteractionManager::GetInstance()->RemoveSubscriptListener(listener);
1297         ASSERT_EQ(ret, RET_OK);
1298     }
1299 }
1300 
1301 /**
1302  * @tc.name: InteractionManagerTest_StartDrag_Mouse
1303  * @tc.desc: Start Drag
1304  * @tc.type: FUNC
1305  * @tc.require:
1306  */
HWTEST_F(InteractionManagerTest, InteractionManagerTest_StartDrag_Mouse, TestSize.Level1)1307 HWTEST_F(InteractionManagerTest, InteractionManagerTest_StartDrag_Mouse, TestSize.Level1)
1308 {
1309     CALL_TEST_DEBUG;
1310     if (g_deviceMouseId < 0) {
1311         ASSERT_TRUE(g_deviceMouseId < 0);
1312     } else {
1313         std::promise<bool> promiseFlag;
1314         std::future<bool> futureFlag = promiseFlag.get_future();
1315         auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
1316             FI_HILOGD("Param displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
1317                 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
1318             promiseFlag.set_value(true);
1319         };
1320         SimulateDownPointerEvent(
1321             { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID);
1322         std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
1323             MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
1324         ASSERT_TRUE(dragData);
1325         int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1326             std::make_shared<UnitTestStartDragListener>(callback));
1327         ASSERT_EQ(ret, RET_OK);
1328         ret = InteractionManager::GetInstance()->SetDragWindowVisible(true);
1329         InteractionManager::GetInstance()->SetDragWindowScreenId(TOUCH_POINTER_ID, TOUCH_POINTER_ID);
1330         EXPECT_EQ(ret, RET_OK);
1331         SimulateMovePointerEvent({ DRAG_SRC_X, DRAG_SRC_Y }, { DRAG_DST_X, DRAG_DST_Y },
1332             MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, true);
1333         DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
1334         InteractionManager::GetInstance()->StopDrag(dropResult);
1335         ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
1336             std::future_status::timeout);
1337     }
1338 }
1339 
1340 /**
1341  * @tc.name: InteractionManagerTest_StartDrag_Failed_Mouse
1342  * @tc.desc: Start Drag
1343  * @tc.type: FUNC
1344  * @tc.require:
1345  */
HWTEST_F(InteractionManagerTest, InteractionManagerTest_StartDrag_Failed_Mouse, TestSize.Level1)1346 HWTEST_F(InteractionManagerTest, InteractionManagerTest_StartDrag_Failed_Mouse, TestSize.Level1)
1347 {
1348     CALL_TEST_DEBUG;
1349     if (g_deviceMouseId < 0) {
1350         ASSERT_TRUE(g_deviceMouseId < 0);
1351     } else {
1352         std::promise<bool> promiseFlag;
1353         std::future<bool> futureFlag = promiseFlag.get_future();
1354         SimulateDownPointerEvent(
1355             { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID);
1356         auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
1357             FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
1358                 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
1359             promiseFlag.set_value(true);
1360         };
1361         std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
1362             MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
1363         ASSERT_TRUE(dragData);
1364 
1365         int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(), nullptr);
1366         ASSERT_EQ(ret, RET_ERR);
1367         dragData->shadowInfos = {};
1368         ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1369             std::make_shared<UnitTestStartDragListener>(callback));
1370         ASSERT_EQ(ret, ERR_INVALID_VALUE);
1371     }
1372 }
1373 
1374 /**
1375  * @tc.name: InteractionManagerTest_StopDrag_Mouse
1376  * @tc.desc: Stop drag
1377  * @tc.type: FUNC
1378  * @tc.require:
1379  */
HWTEST_F(InteractionManagerTest, InteractionManagerTest_StopDrag_Mouse, TestSize.Level1)1380 HWTEST_F(InteractionManagerTest, InteractionManagerTest_StopDrag_Mouse, TestSize.Level1)
1381 {
1382     CALL_TEST_DEBUG;
1383     if (g_deviceMouseId < 0) {
1384         ASSERT_TRUE(g_deviceMouseId < 0);
1385     } else {
1386         std::promise<bool> promiseFlag;
1387         std::future<bool> futureFlag = promiseFlag.get_future();
1388         auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
1389             FI_HILOGD("displayX:%{public}d, displayY:%{public}d, target:%{public}d, result:%{public}d",
1390                 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.targetPid, notifyMessage.result);
1391             promiseFlag.set_value(true);
1392         };
1393         SimulateDownPointerEvent(
1394             { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID);
1395         std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
1396             MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
1397         ASSERT_TRUE(dragData);
1398         int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1399             std::make_shared<UnitTestStartDragListener>(callback));
1400         ASSERT_EQ(ret, RET_OK);
1401         DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
1402         InteractionManager::GetInstance()->StopDrag(dropResult);
1403         ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
1404             std::future_status::timeout);
1405     }
1406 }
1407 
1408 /**
1409  * @tc.name: InteractionManagerTest_StopDrag_Failed_Mouse
1410  * @tc.desc: Stop drag
1411  * @tc.type: FUNC
1412  * @tc.require:
1413  */
HWTEST_F(InteractionManagerTest, InteractionManagerTest_StopDrag_Failed_Mouse, TestSize.Level1)1414 HWTEST_F(InteractionManagerTest, InteractionManagerTest_StopDrag_Failed_Mouse, TestSize.Level1)
1415 {
1416     CALL_TEST_DEBUG;
1417     if (g_deviceMouseId < 0) {
1418         ASSERT_TRUE(g_deviceMouseId < 0);
1419     } else {
1420         SimulateDownPointerEvent(
1421             { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID);
1422         std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
1423             MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
1424         ASSERT_TRUE(dragData);
1425         int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(), nullptr);
1426         ASSERT_EQ(ret, RET_ERR);
1427         DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
1428         ret = InteractionManager::GetInstance()->StopDrag(dropResult);
1429         ASSERT_EQ(ret, RET_ERR);
1430     }
1431 }
1432 
1433 /**
1434  * @tc.name: InteractionManagerTest_StartDrag_Touch
1435  * @tc.desc: Start Drag
1436  * @tc.type: FUNC
1437  * @tc.require:
1438  */
HWTEST_F(InteractionManagerTest, InteractionManagerTest_StartDrag_Touch, TestSize.Level1)1439 HWTEST_F(InteractionManagerTest, InteractionManagerTest_StartDrag_Touch, TestSize.Level1)
1440 {
1441     CALL_TEST_DEBUG;
1442     if (g_deviceTouchId < 0) {
1443         ASSERT_TRUE(g_deviceTouchId < 0);
1444     } else {
1445         SimulateDownPointerEvent(
1446             { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID);
1447         std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_TOUCH_DOWN_MS));
1448         std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
1449             MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
1450         ASSERT_TRUE(dragData);
1451         std::promise<bool> promiseFlag;
1452         std::future<bool> futureFlag = promiseFlag.get_future();
1453         auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
1454             FI_HILOGD("Start drag, displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
1455                 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
1456             promiseFlag.set_value(true);
1457         };
1458         int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1459             std::make_shared<UnitTestStartDragListener>(callback));
1460         ASSERT_EQ(ret, RET_OK);
1461         ret = InteractionManager::GetInstance()->SetDragWindowVisible(true);
1462         EXPECT_EQ(ret, RET_OK);
1463         SimulateMovePointerEvent({ DRAG_SRC_X, DRAG_SRC_Y }, { DRAG_DST_X, DRAG_DST_Y },
1464             MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, true);
1465         DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
1466         InteractionManager::GetInstance()->StopDrag(dropResult);
1467         ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
1468             std::future_status::timeout);
1469     }
1470 }
1471 
1472 /**
1473  * @tc.name: InteractionManagerTest_StopDrag_Touch
1474  * @tc.desc: Stop drag
1475  * @tc.type: FUNC
1476  * @tc.require:
1477  */
HWTEST_F(InteractionManagerTest, InteractionManagerTest_StopDrag_Touch, TestSize.Level1)1478 HWTEST_F(InteractionManagerTest, InteractionManagerTest_StopDrag_Touch, TestSize.Level1)
1479 {
1480     CALL_TEST_DEBUG;
1481     if (g_deviceTouchId < 0) {
1482         ASSERT_TRUE(g_deviceTouchId < 0);
1483     } else {
1484         std::promise<bool> promiseFlag;
1485         std::future<bool> future = promiseFlag.get_future();
1486         auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
1487             FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
1488                 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
1489             promiseFlag.set_value(true);
1490         };
1491         SimulateDownPointerEvent(
1492             { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID);
1493         std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_TOUCH_DOWN_MS));
1494         std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
1495             MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
1496         ASSERT_TRUE(dragData);
1497         int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1498             std::make_shared<UnitTestStartDragListener>(callback));
1499         ASSERT_EQ(ret, RET_OK);
1500         DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
1501         InteractionManager::GetInstance()->StopDrag(dropResult);
1502         ASSERT_TRUE(future.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
1503             std::future_status::timeout);
1504     }
1505 }
1506 
1507 /**
1508  * @tc.name: GetDragTargetPid_Mouse
1509  * @tc.desc: Get the target pid dragged by the mouse
1510  * @tc.type: FUNC
1511  * @tc.require:
1512  */
HWTEST_F(InteractionManagerTest, GetDragTargetPid_Mouse, TestSize.Level1)1513 HWTEST_F(InteractionManagerTest, GetDragTargetPid_Mouse, TestSize.Level1)
1514 {
1515     CALL_TEST_DEBUG;
1516     if (g_deviceMouseId < 0) {
1517         ASSERT_TRUE(g_deviceMouseId < 0);
1518     } else {
1519         std::promise<bool> promiseStopFlag;
1520         std::future<bool> futureStopFlag = promiseStopFlag.get_future();
1521         auto callback = [&promiseStopFlag](const DragNotifyMsg& notifyMessage) {
1522             FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
1523                 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
1524             promiseStopFlag.set_value(true);
1525         };
1526         SimulateDownPointerEvent(
1527             { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID);
1528         std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
1529             MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
1530         ASSERT_TRUE(dragData);
1531         int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1532             std::make_shared<UnitTestStartDragListener>(callback));
1533         ASSERT_EQ(ret, RET_OK);
1534         ret = InteractionManager::GetInstance()->SetDragWindowVisible(true);
1535         EXPECT_EQ(ret, RET_OK);
1536         ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::DEFAULT);
1537         ASSERT_EQ(ret, RET_OK);
1538         int32_t pid = InteractionManager::GetInstance()->GetDragTargetPid();
1539         FI_HILOGI("Target pid:%{public}d", pid);
1540         ASSERT_TRUE(pid > 0);
1541         DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
1542         InteractionManager::GetInstance()->StopDrag(dropResult);
1543         ASSERT_TRUE(futureStopFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
1544             std::future_status::timeout);
1545     }
1546 }
1547 
1548 /**
1549  * @tc.name: GetDragTargetPid_Touch
1550  * @tc.desc: Get the target pid dragged by the touchscreen
1551  * @tc.type: FUNC
1552  * @tc.require:
1553  */
HWTEST_F(InteractionManagerTest, GetDragTargetPid_Touch, TestSize.Level1)1554 HWTEST_F(InteractionManagerTest, GetDragTargetPid_Touch, TestSize.Level1)
1555 {
1556     CALL_TEST_DEBUG;
1557     if (g_deviceTouchId < 0) {
1558         ASSERT_TRUE(g_deviceTouchId < 0);
1559     } else {
1560         std::promise<bool> promiseStopFlag;
1561         std::future<bool> futureStopFlag = promiseStopFlag.get_future();
1562         auto callback = [&promiseStopFlag](const DragNotifyMsg& notifyMessage) {
1563             FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
1564                 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
1565             promiseStopFlag.set_value(true);
1566         };
1567         SimulateDownPointerEvent(
1568             { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID);
1569         std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_TOUCH_DOWN_MS));
1570         std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
1571             MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
1572         ASSERT_TRUE(dragData);
1573         int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1574             std::make_shared<UnitTestStartDragListener>(callback));
1575         ASSERT_EQ(ret, RET_OK);
1576         ret = InteractionManager::GetInstance()->SetDragWindowVisible(true);
1577         EXPECT_EQ(ret, RET_OK);
1578         ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::COPY);
1579         ASSERT_EQ(ret, RET_OK);
1580         int32_t pid = InteractionManager::GetInstance()->GetDragTargetPid();
1581         FI_HILOGI("Target pid:%{public}d", pid);
1582         ASSERT_TRUE(pid > 0);
1583         DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
1584         InteractionManager::GetInstance()->StopDrag(dropResult);
1585         ASSERT_TRUE(futureStopFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
1586             std::future_status::timeout);
1587     }
1588 }
1589 
1590 /**
1591  * @tc.name: TouchEventDispatch
1592  * @tc.desc: Dispatch the touchscreen events
1593  * @tc.type: FUNC
1594  * @tc.require:
1595  */
HWTEST_F(InteractionManagerTest, TouchEventDispatch, TestSize.Level1)1596 HWTEST_F(InteractionManagerTest, TouchEventDispatch, TestSize.Level1)
1597 {
1598     CALL_TEST_DEBUG;
1599     if (g_deviceTouchId < 0) {
1600         ASSERT_TRUE(g_deviceTouchId < 0);
1601     } else {
1602         std::promise<bool> promiseFlag;
1603         std::future<bool> futureFlag = promiseFlag.get_future();
1604         auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
1605             FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
1606                 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
1607             promiseFlag.set_value(true);
1608         };
1609         SimulateDownPointerEvent(
1610             { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID);
1611         std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_TOUCH_DOWN_MS));
1612         std::optional<DragData> dragDataInfo = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
1613             MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID_INJECT, DISPLAY_ID,
1614             { DRAG_SRC_X, DRAG_SRC_Y });
1615         ASSERT_TRUE(dragDataInfo);
1616         int32_t result = InteractionManager::GetInstance()->StartDrag(dragDataInfo.value(),
1617             std::make_shared<UnitTestStartDragListener>(callback));
1618         ASSERT_EQ(result, RET_OK);
1619         result = InteractionManager::GetInstance()->SetDragWindowVisible(true);
1620         EXPECT_EQ(result, RET_OK);
1621         SetPermission(SYSTEM_CORE, g_cores, sizeof(g_cores) / sizeof(g_cores[0]));
1622         std::promise<bool> promiseEventFlag;
1623         std::future<bool> futureEventFlag = promiseEventFlag.get_future();
1624         auto callbackPtr = std::make_shared<InputEventCallbackTest>(
1625             [&promiseEventFlag]{promiseEventFlag.set_value(true);});
1626         int32_t monitorId = TestAddMonitor(callbackPtr);
1627         SimulateMovePointerEvent({ DRAG_SRC_X, DRAG_SRC_Y }, { DRAG_DST_X, DRAG_DST_Y },
1628             MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID_INJECT, true);
1629         ASSERT_TRUE(futureEventFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
1630             std::future_status::timeout);
1631         SetPermission(SYSTEM_CORE, g_cores, sizeof(g_cores) / sizeof(g_cores[0]));
1632         TestRemoveMonitor(monitorId);
1633         DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
1634         result = InteractionManager::GetInstance()->StopDrag(dropResult);
1635         ASSERT_EQ(result, RET_OK);
1636         ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
1637             std::future_status::timeout);
1638         RemovePermission();
1639     }
1640 }
1641 
1642 /**
1643  * @tc.name: MouseEventDispatch
1644  * @tc.desc: Dispatch the mouse events
1645  * @tc.type: FUNC
1646  * @tc.require:
1647  */
HWTEST_F(InteractionManagerTest, MouseEventDispatch, TestSize.Level1)1648 HWTEST_F(InteractionManagerTest, MouseEventDispatch, TestSize.Level1)
1649 {
1650     CALL_TEST_DEBUG;
1651     if (g_deviceMouseId < 0) {
1652         ASSERT_TRUE(g_deviceMouseId < 0);
1653     } else {
1654         std::promise<bool> promiseFlag;
1655         std::future<bool> futureFlag = promiseFlag.get_future();
1656         auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
1657             FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
1658                 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
1659             promiseFlag.set_value(true);
1660         };
1661         SimulateDownPointerEvent(
1662             { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_MOUSE, 0);
1663         std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
1664             MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID_INJECT, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
1665         ASSERT_TRUE(dragData);
1666         int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1667             std::make_shared<UnitTestStartDragListener>(callback));
1668         ASSERT_EQ(ret, RET_OK);
1669         ret = InteractionManager::GetInstance()->SetDragWindowVisible(true);
1670         EXPECT_EQ(ret, RET_OK);
1671         SetPermission(SYSTEM_CORE, g_cores, sizeof(g_cores) / sizeof(g_cores[0]));
1672         std::promise<bool> promiseEventFlag;
1673         std::future<bool> futureEventFlag = promiseEventFlag.get_future();
1674         auto callbackPtr = std::make_shared<InputEventCallbackTest>(
1675             [&promiseEventFlag]{promiseEventFlag.set_value(true);});
1676         int32_t monitorId = TestAddMonitor(callbackPtr);
1677         SimulateMovePointerEvent({ DRAG_SRC_X, DRAG_SRC_Y }, { DRAG_DST_X, DRAG_DST_Y },
1678             MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID_INJECT, true);
1679         ASSERT_TRUE(futureEventFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
1680             std::future_status::timeout);
1681         SetPermission(SYSTEM_CORE, g_cores, sizeof(g_cores) / sizeof(g_cores[0]));
1682         TestRemoveMonitor(monitorId);
1683         DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
1684         ret = InteractionManager::GetInstance()->StopDrag(dropResult);
1685         ASSERT_EQ(ret, RET_OK);
1686         ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
1687             std::future_status::timeout);
1688     }
1689     RemovePermission();
1690 }
1691 
1692 /**
1693  * @tc.name: InteractionManagerTest_SetDragWindowVisible
1694  * @tc.desc: Set Drag Window Visible
1695  * @tc.type: FUNC
1696  * @tc.require:
1697  */
HWTEST_F(InteractionManagerTest, InteractionManagerTest_SetDragWindowVisible, TestSize.Level1)1698 HWTEST_F(InteractionManagerTest, InteractionManagerTest_SetDragWindowVisible, TestSize.Level1)
1699 {
1700     CALL_TEST_DEBUG;
1701     int32_t ret = InteractionManager::GetInstance()->SetDragWindowVisible(true);
1702     FI_HILOGD("ret:%{public}d", ret);
1703     ASSERT_EQ(ret, RET_ERR);
1704     ret = InteractionManager::GetInstance()->SetDragWindowVisible(false);
1705     FI_HILOGD("ret:%{public}d", ret);
1706     ASSERT_EQ(ret, RET_ERR);
1707 }
1708 
1709 /**
1710  * @tc.name: InteractionManagerTest_GetShadowOffset
1711  * @tc.desc: Get Shadow Offset
1712  * @tc.type: FUNC
1713  * @tc.require:
1714  */
HWTEST_F(InteractionManagerTest, InteractionManagerTest_GetShadowOffset, TestSize.Level1)1715 HWTEST_F(InteractionManagerTest, InteractionManagerTest_GetShadowOffset, TestSize.Level1)
1716 {
1717     CALL_TEST_DEBUG;
1718     int32_t offsetX = 0;
1719     int32_t offsetY = 0;
1720     int32_t width = 0;
1721     int32_t height = 0;
1722     std::promise<bool> promise;
1723     std::future<bool> futureFlag = promise.get_future();
1724     auto callback = [&promise](const DragNotifyMsg& notifyMessage) {
1725         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
1726             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
1727         promise.set_value(true);
1728     };
1729     SimulateDownPointerEvent(
1730         { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID);
1731     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_TOUCH_DOWN_MS));
1732     std::optional<DragData> dragDataInfo = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
1733         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
1734     ASSERT_TRUE(dragDataInfo);
1735     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragDataInfo.value(),
1736         std::make_shared<UnitTestStartDragListener>(callback));
1737     ASSERT_EQ(ret, RET_OK);
1738     ret = InteractionManager::GetInstance()->GetShadowOffset(offsetX, offsetY, width, height);
1739     FI_HILOGD("offsetX:%{public}d, offsetY:%{public}d, width:%{public}d, height:%{public}d",
1740         offsetX, offsetY, width, height);
1741     ASSERT_EQ(ret, RET_OK);
1742     DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
1743     ret = InteractionManager::GetInstance()->StopDrag(dropResult);
1744     ASSERT_EQ(ret, RET_OK);
1745     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) != std::future_status::timeout);
1746 }
1747 
1748 /**
1749  * @tc.name: GetUdKey_Mouse
1750  * @tc.desc: Get the udKey dragged by the mouse
1751  * @tc.type: FUNC
1752  * @tc.require:
1753  */
HWTEST_F(InteractionManagerTest, GetUdKey_Mouse, TestSize.Level1)1754 HWTEST_F(InteractionManagerTest, GetUdKey_Mouse, TestSize.Level1)
1755 {
1756     CALL_TEST_DEBUG;
1757     if (g_deviceMouseId < 0) {
1758         ASSERT_TRUE(g_deviceMouseId < 0);
1759     } else {
1760         SimulateDownPointerEvent(
1761             { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID);
1762         std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
1763             MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
1764         ASSERT_TRUE(dragData);
1765         std::promise<bool> promiseFlag;
1766         std::future<bool> futureFlag = promiseFlag.get_future();
1767         auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
1768             FI_HILOGD("Get ud key, displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
1769                 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
1770             promiseFlag.set_value(true);
1771         };
1772         int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1773             std::make_shared<UnitTestStartDragListener>(callback));
1774         ASSERT_EQ(ret, RET_OK);
1775         std::string udKey;
1776         ret = InteractionManager::GetInstance()->GetUdKey(udKey);
1777         ASSERT_EQ(ret, RET_OK);
1778         ASSERT_EQ(udKey, UD_KEY);
1779         DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
1780         ret = InteractionManager::GetInstance()->StopDrag(dropResult);
1781         ASSERT_EQ(ret, RET_OK);
1782         ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
1783             std::future_status::timeout);
1784     }
1785 }
1786 
1787 /**
1788  * @tc.name: GetUdKey_Touch
1789  * @tc.desc: Get the udKey dragged by the touchscreen
1790  * @tc.type: FUNC
1791  * @tc.require:
1792  */
HWTEST_F(InteractionManagerTest, GetUdKey_Touch, TestSize.Level1)1793 HWTEST_F(InteractionManagerTest, GetUdKey_Touch, TestSize.Level1)
1794 {
1795     CALL_TEST_DEBUG;
1796     if (g_deviceTouchId < 0) {
1797         ASSERT_TRUE(g_deviceTouchId < 0);
1798     } else {
1799         std::promise<bool> promiseFlag;
1800         std::future<bool> futureFlag = promiseFlag.get_future();
1801         auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
1802             FI_HILOGD("displayX:%{public}d, displayY:%{public}d, target:%{public}d, result:%{public}d",
1803                 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.targetPid, notifyMessage.result);
1804             promiseFlag.set_value(true);
1805         };
1806         SimulateDownPointerEvent(
1807             { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID);
1808         std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_TOUCH_DOWN_MS));
1809         std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
1810             MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
1811         ASSERT_TRUE(dragData);
1812         int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1813             std::make_shared<UnitTestStartDragListener>(callback));
1814         ASSERT_EQ(ret, RET_OK);
1815         std::string udKey;
1816         ret = InteractionManager::GetInstance()->GetUdKey(udKey);
1817         ASSERT_EQ(ret, RET_OK);
1818         ASSERT_EQ(udKey, UD_KEY);
1819         DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
1820         ret = InteractionManager::GetInstance()->StopDrag(dropResult);
1821         ASSERT_EQ(ret, RET_OK);
1822         ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
1823             std::future_status::timeout);
1824     }
1825 }
1826 
1827 /**
1828  * @tc.name: GetDragData_Success
1829  * @tc.desc: Get the dragData from interface successfully
1830  * @tc.type: FUNC
1831  * @tc.require:
1832  */
HWTEST_F(InteractionManagerTest, GetDragData_Success, TestSize.Level1)1833 HWTEST_F(InteractionManagerTest, GetDragData_Success, TestSize.Level1)
1834 {
1835     CALL_TEST_DEBUG;
1836     if (g_deviceTouchId < 0) {
1837         ASSERT_TRUE(g_deviceTouchId < 0);
1838     } else {
1839         std::promise<bool> promiseFlag;
1840         std::future<bool> futureFlag = promiseFlag.get_future();
1841         auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
1842             FI_HILOGD("Get drag data, displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
1843                 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
1844             promiseFlag.set_value(true);
1845         };
1846         SimulateDownPointerEvent(
1847             { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID);
1848         std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
1849             MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
1850         ASSERT_TRUE(dragData);
1851         int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1852             std::make_shared<UnitTestStartDragListener>(callback));
1853         ASSERT_EQ(ret, RET_OK);
1854 
1855         DragData replyDragData;
1856         ret = InteractionManager::GetInstance()->GetDragData(replyDragData);
1857         ASSERT_EQ(ret, RET_OK);
1858         ASSERT_EQ(replyDragData, dragData.value());
1859         PrintDragData(replyDragData);
1860         SimulateUpPointerEvent(
1861             { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID);
1862         DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
1863         InteractionManager::GetInstance()->StopDrag(dropResult);
1864         ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
1865             std::future_status::timeout);
1866     }
1867 }
1868 
1869 /**
1870  * @tc.name: GetDragData_Failed
1871  * @tc.desc: Get the dragData from interface failed
1872  * @tc.type: FUNC
1873  * @tc.require:
1874  */
HWTEST_F(InteractionManagerTest, GetDragData_Failed, TestSize.Level1)1875 HWTEST_F(InteractionManagerTest, GetDragData_Failed, TestSize.Level1)
1876 {
1877     CALL_TEST_DEBUG;
1878     if (g_deviceTouchId < 0) {
1879         ASSERT_TRUE(g_deviceTouchId < 0);
1880     } else {
1881         SimulateDownPointerEvent(
1882             { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID);
1883         std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_TOUCH_DOWN_MS));
1884         DragData dragData;
1885         int32_t ret = InteractionManager::GetInstance()->GetDragData(dragData);
1886         SimulateUpPointerEvent(
1887             { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID);
1888         ASSERT_EQ(ret, RET_ERR);
1889     }
1890 }
1891 
1892 /**
1893  * @tc.name: GetDragState
1894  * @tc.desc: Get the dragState from interface
1895  * @tc.type: FUNC
1896  * @tc.require:
1897  */
HWTEST_F(InteractionManagerTest, GetDragState, TestSize.Level1)1898 HWTEST_F(InteractionManagerTest, GetDragState, TestSize.Level1)
1899 {
1900     CALL_TEST_DEBUG;
1901     std::promise<bool> promiseFlag;
1902     std::future<bool> futureFlag = promiseFlag.get_future();
1903     auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
1904         FI_HILOGD("Drag state, displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
1905             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
1906         promiseFlag.set_value(true);
1907     };
1908     SimulateDownPointerEvent(
1909         { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID);
1910     std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
1911         MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
1912     ASSERT_TRUE(dragData);
1913     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1914         std::make_shared<UnitTestStartDragListener>(callback));
1915     ASSERT_EQ(ret, RET_OK);
1916 
1917     DragState dragState;
1918     ret = InteractionManager::GetInstance()->GetDragState(dragState);
1919     FI_HILOGD("InteractionManager::dragState:%{public}d", dragState);
1920     EXPECT_EQ(ret, RET_OK);
1921     EXPECT_EQ(dragState, DragState::START);
1922 
1923     SimulateUpPointerEvent(
1924         { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID);
1925     DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
1926     ret = InteractionManager::GetInstance()->StopDrag(dropResult);
1927     ASSERT_EQ(ret, RET_OK);
1928     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
1929         std::future_status::timeout);
1930     ret = InteractionManager::GetInstance()->GetDragState(dragState);
1931     FI_HILOGD("dragState:%{public}d", dragState);
1932     EXPECT_EQ(ret, RET_OK);
1933     EXPECT_EQ(dragState, DragState::STOP);
1934 }
1935 
1936 /**
1937  * @tc.name: InteractionManagerTest_GetDragSummary
1938  * @tc.desc: Get drag summarys
1939  * @tc.type: FUNC
1940  * @tc.require:
1941  */
HWTEST_F(InteractionManagerTest, InteractionManagerTest_GetDragSummary, TestSize.Level1)1942 HWTEST_F(InteractionManagerTest, InteractionManagerTest_GetDragSummary, TestSize.Level1)
1943 {
1944     CALL_TEST_DEBUG;
1945     std::promise<bool> promiseFlag;
1946     std::future<bool> futureFlag = promiseFlag.get_future();
1947     auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
1948         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
1949             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
1950         promiseFlag.set_value(true);
1951     };
1952     std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
1953         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
1954     ASSERT_TRUE(dragData);
1955     const std::string udType = "general.message";
1956     constexpr int64_t recordSize = 20;
1957     std::map<std::string, int64_t> summarys = { { udType, recordSize } };
1958     dragData.value().summarys = summarys;
1959     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1960         std::make_shared<UnitTestStartDragListener>(callback));
1961     ASSERT_EQ(ret, RET_OK);
1962     summarys.clear();
1963     ret = InteractionManager::GetInstance()->GetDragSummary(summarys);
1964     EXPECT_EQ(ret, RET_OK);
1965     EXPECT_EQ(summarys[udType], recordSize);
1966     DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
1967     InteractionManager::GetInstance()->StopDrag(dropResult);
1968     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
1969         std::future_status::timeout);
1970 }
1971 
1972 /**
1973  * @tc.name: InteractionManagerTest_UpdatePreviewStyle
1974  * @tc.desc: Update drag item style
1975  * @tc.type: FUNC
1976  * @tc.require:
1977  */
HWTEST_F(InteractionManagerTest, InteractionManagerTest_UpdatePreviewStyle, TestSize.Level1)1978 HWTEST_F(InteractionManagerTest, InteractionManagerTest_UpdatePreviewStyle, TestSize.Level1)
1979 {
1980     CALL_TEST_DEBUG;
1981     std::promise<bool> promiseFlag;
1982     std::future<bool> futureFlag = promiseFlag.get_future();
1983     auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
1984         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
1985             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
1986         promiseFlag.set_value(true);
1987     };
1988     SimulateDownPointerEvent(
1989         { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID);
1990     std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
1991         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
1992     ASSERT_TRUE(dragData);
1993     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1994         std::make_shared<UnitTestStartDragListener>(callback));
1995     ASSERT_EQ(ret, RET_OK);
1996     ret = InteractionManager::GetInstance()->SetDragWindowVisible(true);
1997     EXPECT_EQ(ret, RET_OK);
1998     std::pair<int32_t, int32_t> enterPos { 500, 50 };
1999     std::pair<int32_t, int32_t> leavePos { 500, 200 };
2000     SimulateMovePointerEvent({ DRAG_SRC_X, DRAG_SRC_Y }, { enterPos.first, enterPos.second },
2001         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, true);
2002     PreviewStyle previewStyleIn;
2003     previewStyleIn.types = { PreviewType::FOREGROUND_COLOR };
2004     previewStyleIn.foregroundColor = FOREGROUND_COLOR_IN;
2005     ret = InteractionManager::GetInstance()->UpdatePreviewStyle(previewStyleIn);
2006     EXPECT_EQ(ret, RET_OK);
2007     SimulateMovePointerEvent({ enterPos.first, enterPos.second }, { leavePos.first, leavePos.second },
2008         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, true);
2009     PreviewStyle previewStyleOut;
2010     previewStyleOut.types = { PreviewType::FOREGROUND_COLOR };
2011     previewStyleOut.foregroundColor = FOREGROUND_COLOR_OUT;
2012     ret = InteractionManager::GetInstance()->UpdatePreviewStyle(previewStyleOut);
2013     EXPECT_EQ(ret, RET_OK);
2014     SimulateMovePointerEvent({ leavePos.first, leavePos.second }, { DRAG_DST_X, DRAG_DST_Y },
2015         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, true);
2016     DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
2017     InteractionManager::GetInstance()->StopDrag(dropResult);
2018     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
2019         std::future_status::timeout);
2020 }
2021 
2022 
2023 /**
2024  * @tc.name: InteractionManagerTest_UpdatePreviewStyleWithAnimation
2025  * @tc.desc: Update drag item style with animation
2026  * @tc.type: FUNC
2027  * @tc.require:
2028  */
HWTEST_F(InteractionManagerTest, InteractionManagerTest_UpdatePreviewStyleWithAnimation, TestSize.Level1)2029 HWTEST_F(InteractionManagerTest, InteractionManagerTest_UpdatePreviewStyleWithAnimation, TestSize.Level1)
2030 {
2031     CALL_TEST_DEBUG;
2032     std::promise<bool> promiseFlag;
2033     std::future<bool> futureFlag = promiseFlag.get_future();
2034     auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
2035         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
2036             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
2037         promiseFlag.set_value(true);
2038     };
2039     SimulateDownPointerEvent({ DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID);
2040     std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
2041         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
2042     ASSERT_TRUE(dragData);
2043     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
2044         std::make_shared<UnitTestStartDragListener>(callback));
2045     ASSERT_EQ(ret, RET_OK);
2046     ret = InteractionManager::GetInstance()->SetDragWindowVisible(true);
2047     EXPECT_EQ(ret, RET_OK);
2048     std::pair<int32_t, int32_t> enterPos { 500, 50 };
2049     std::pair<int32_t, int32_t> leavePos { 500, 200 };
2050     SimulateMovePointerEvent({ DRAG_SRC_X, DRAG_SRC_Y }, { enterPos.first, enterPos.second },
2051         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, true);
2052     PreviewStyle previewStyleIn;
2053     previewStyleIn.types = { PreviewType::FOREGROUND_COLOR };
2054     previewStyleIn.foregroundColor = FOREGROUND_COLOR_IN;
2055     PreviewAnimation animationIn;
2056     AssignToAnimation(animationIn);
2057     ret = InteractionManager::GetInstance()->UpdatePreviewStyleWithAnimation(previewStyleIn, animationIn);
2058     EXPECT_EQ(ret, RET_OK);
2059     SimulateMovePointerEvent({ enterPos.first, enterPos.second }, { leavePos.first, leavePos.second },
2060         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, true);
2061     PreviewStyle previewStyleOut;
2062     previewStyleOut.types = { PreviewType::FOREGROUND_COLOR };
2063     previewStyleOut.foregroundColor = FOREGROUND_COLOR_OUT;
2064     PreviewAnimation animationOut;
2065     AssignToAnimation(animationOut);
2066     ret = InteractionManager::GetInstance()->UpdatePreviewStyleWithAnimation(previewStyleOut, animationOut);
2067     EXPECT_EQ(ret, RET_OK);
2068     SimulateMovePointerEvent({ leavePos.first, leavePos.second }, { DRAG_DST_X, DRAG_DST_Y },
2069         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, true);
2070     DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
2071     InteractionManager::GetInstance()->StopDrag(dropResult);
2072     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
2073         std::future_status::timeout);
2074 }
2075 
2076 /**
2077  * @tc.name: InteractionManagerTest_GetExtraInfo
2078  * @tc.desc: Get extraInfo
2079  * @tc.type: FUNC
2080  * @tc.require:
2081  */
HWTEST_F(InteractionManagerTest, InteractionManagerTest_GetExtraInfo, TestSize.Level1)2082 HWTEST_F(InteractionManagerTest, InteractionManagerTest_GetExtraInfo, TestSize.Level1)
2083 {
2084     CALL_TEST_DEBUG;
2085     if (g_deviceMouseId >= 0) {
2086         SimulateDownPointerEvent(
2087             { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID);
2088         std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
2089             MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
2090         ASSERT_TRUE(dragData);
2091         std::promise<bool> promiseFlag;
2092         std::future<bool> futureFlag = promiseFlag.get_future();
2093         auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
2094             FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
2095                 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
2096             promiseFlag.set_value(true);
2097         };
2098         int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
2099             std::make_shared<UnitTestStartDragListener>(callback));
2100         ASSERT_EQ(ret, RET_OK);
2101         std::string extraInfo;
2102         ret = InteractionManager::GetInstance()->GetExtraInfo(extraInfo);
2103         ASSERT_EQ(ret, RET_OK);
2104         ASSERT_EQ(extraInfo, EXTRA_INFO);
2105         DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
2106         ret = InteractionManager::GetInstance()->StopDrag(dropResult);
2107         ASSERT_EQ(ret, RET_OK);
2108         ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
2109             std::future_status::timeout);
2110     }
2111 }
2112 
2113 /**
2114  * @tc.name: TestDragDataUtil_Packer
2115  * @tc.desc: Pack up dragData
2116  * @tc.type: FUNC
2117  * @tc.require:
2118  */
HWTEST_F(InteractionManagerTest, TestDragDataUtil_Packer, TestSize.Level1)2119 HWTEST_F(InteractionManagerTest, TestDragDataUtil_Packer, TestSize.Level1)
2120 {
2121     CALL_TEST_DEBUG;
2122     std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
2123         MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
2124     ASSERT_TRUE(dragData);
2125     Parcel parcel;
2126     int32_t ret = DragDataUtil::Marshalling(dragData.value(), parcel, false);
2127     ASSERT_EQ(ret, RET_OK);
2128     DragData dragDataFromParcel;
2129     ret = DragDataUtil::UnMarshalling(parcel, dragDataFromParcel, false);
2130     ASSERT_EQ(ret, RET_OK);
2131     ASSERT_EQ(dragData.value(), dragDataFromParcel);
2132 }
2133 
2134 /**
2135  * @tc.name: TestDragDataUtil_Packer_Cross
2136  * @tc.desc: Pack up dragData
2137  * @tc.type: FUNC
2138  * @tc.require:
2139  */
HWTEST_F(InteractionManagerTest, TestDragDataUtil_Packer_Cross, TestSize.Level1)2140 HWTEST_F(InteractionManagerTest, TestDragDataUtil_Packer_Cross, TestSize.Level1)
2141 {
2142     CALL_TEST_DEBUG;
2143     std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
2144         MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
2145     ASSERT_TRUE(dragData);
2146     Parcel parcel;
2147     int32_t ret = DragDataUtil::Marshalling(dragData.value(), parcel, true);
2148     ASSERT_EQ(ret, RET_OK);
2149     DragData dragDataFromParcel;
2150     ret = DragDataUtil::UnMarshalling(parcel, dragDataFromParcel, true);
2151     ASSERT_EQ(ret, RET_OK);
2152     ASSERT_EQ(dragData.value(), dragDataFromParcel);
2153 }
2154 
2155 /**
2156  * @tc.name: InteractionManagerTest_GetDragAction_001
2157  * @tc.desc: Get drag action with no keyboard events of keys in dragging
2158  * @tc.type: FUNC
2159  * @tc.require:
2160  */
HWTEST_F(InteractionManagerTest, GetDragAction_001, TestSize.Level1)2161 HWTEST_F(InteractionManagerTest, GetDragAction_001, TestSize.Level1)
2162 {
2163     CALL_TEST_DEBUG;
2164     std::promise<bool> promiseFlag;
2165     std::future<bool> futureFlag = promiseFlag.get_future();
2166     auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
2167         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
2168             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
2169         promiseFlag.set_value(true);
2170     };
2171     std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
2172         MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
2173     ASSERT_TRUE(dragData);
2174     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
2175         std::make_shared<UnitTestStartDragListener>(callback));
2176     ASSERT_EQ(ret, RET_OK);
2177     DragAction dragAction { DragAction::INVALID };
2178     ret = InteractionManager::GetInstance()->GetDragAction(dragAction);
2179     EXPECT_EQ(ret, RET_OK);
2180     EXPECT_EQ(dragAction, DragAction::MOVE);
2181     PrintDragAction(dragAction);
2182     DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
2183     InteractionManager::GetInstance()->StopDrag(dropResult);
2184     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
2185         std::future_status::timeout);
2186     ret = InteractionManager::GetInstance()->GetDragAction(dragAction);
2187     EXPECT_EQ(ret, RET_ERR);
2188 }
2189 
2190 /**
2191  * @tc.name: InteractionManagerTest_GetDragAction_002
2192  * @tc.desc: Get drag action with simple press and release keyboard events of keys in dragging
2193  * @tc.type: FUNC
2194  * @tc.require:
2195  */
HWTEST_F(InteractionManagerTest, GetDragAction_002, TestSize.Level1)2196 HWTEST_F(InteractionManagerTest, GetDragAction_002, TestSize.Level1)
2197 {
2198     CALL_TEST_DEBUG;
2199     std::promise<bool> promiseFlag;
2200     std::future<bool> futureFlag = promiseFlag.get_future();
2201     auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
2202         FI_HILOGD("DisplayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
2203             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
2204         promiseFlag.set_value(true);
2205     };
2206     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_INJECT_MS));
2207     std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
2208         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID_INJECT, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
2209     ASSERT_TRUE(dragData);
2210     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
2211         std::make_shared<UnitTestStartDragListener>(callback));
2212     ASSERT_EQ(ret, RET_OK);
2213     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::MOVE);
2214     ASSERT_EQ(ret, RET_OK);
2215     SimulateMovePointerEvent({ DRAG_SRC_X, DRAG_SRC_Y }, { DRAG_DST_X, DRAG_DST_Y },
2216         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, true);
2217     SimulateDownKeyEvent(MMI::KeyEvent::KEYCODE_CTRL_LEFT);
2218     DragAction dragAction { DragAction::INVALID };
2219     ret = InteractionManager::GetInstance()->GetDragAction(dragAction);
2220     EXPECT_EQ(ret, RET_OK);
2221     EXPECT_EQ(dragAction, DragAction::COPY);
2222     PrintDragAction(dragAction);
2223     SimulateUpKeyEvent(MMI::KeyEvent::KEYCODE_CTRL_LEFT);
2224     ret = InteractionManager::GetInstance()->GetDragAction(dragAction);
2225     EXPECT_EQ(ret, RET_OK);
2226     EXPECT_EQ(dragAction, DragAction::MOVE);
2227     PrintDragAction(dragAction);
2228     ClearUpKeyEvent();
2229     SimulateDownKeyEvent(MMI::KeyEvent::KEYCODE_A);
2230     ret = InteractionManager::GetInstance()->GetDragAction(dragAction);
2231     EXPECT_EQ(ret, RET_OK);
2232     EXPECT_EQ(dragAction, DragAction::MOVE);
2233     PrintDragAction(dragAction);
2234     SimulateUpKeyEvent(MMI::KeyEvent::KEYCODE_A);
2235     ret = InteractionManager::GetInstance()->GetDragAction(dragAction);
2236     EXPECT_EQ(ret, RET_OK);
2237     EXPECT_EQ(dragAction, DragAction::MOVE);
2238     PrintDragAction(dragAction);
2239     ClearUpKeyEvent();
2240     DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
2241     InteractionManager::GetInstance()->StopDrag(dropResult);
2242     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
2243         std::future_status::timeout);
2244     ret = InteractionManager::GetInstance()->GetDragAction(dragAction);
2245     EXPECT_EQ(ret, RET_ERR);
2246 }
2247 
2248 /**
2249  * @tc.name: InteractionManagerTest_GetDragAction_003
2250  * @tc.desc: Get drag action with simple press and release keyboard events of keys in start drag
2251  * @tc.type: FUNC
2252  * @tc.require:
2253  */
HWTEST_F(InteractionManagerTest, GetDragAction_003, TestSize.Level1)2254 HWTEST_F(InteractionManagerTest, GetDragAction_003, TestSize.Level1)
2255 {
2256     CALL_TEST_DEBUG;
2257     if (g_deviceMouseId < 0) {
2258         ASSERT_TRUE(g_deviceMouseId < 0);
2259     } else {
2260         int32_t ret = RET_ERR;
2261         std::promise<bool> promiseFlag;
2262         std::future<bool> futureFlag = promiseFlag.get_future();
2263         auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
2264             FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
2265                 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
2266             promiseFlag.set_value(true);
2267         };
2268         std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
2269             MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
2270         ASSERT_TRUE(dragData);
2271         ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
2272             std::make_shared<UnitTestStartDragListener>(callback));
2273         ASSERT_EQ(ret, RET_OK);
2274         ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::MOVE);
2275         ASSERT_EQ(ret, RET_OK);
2276         DragAction dragAction { DragAction::INVALID };
2277         ret = InteractionManager::GetInstance()->GetDragAction(dragAction);
2278         EXPECT_EQ(ret, RET_OK);
2279         EXPECT_EQ(dragAction, DragAction::MOVE);
2280         PrintDragAction(dragAction);
2281         DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
2282         InteractionManager::GetInstance()->StopDrag(dropResult);
2283         ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
2284             std::future_status::timeout);
2285         ret = InteractionManager::GetInstance()->GetDragAction(dragAction);
2286         EXPECT_EQ(ret, RET_ERR);
2287     }
2288 }
2289 
2290 /**
2291  * @tc.name: InteractionManagerTest_GetDragAction_004
2292  * @tc.desc: Get drag action with multiple press and release keyboard events of keys in dragging
2293  * @tc.type: FUNC
2294  * @tc.require:
2295  */
HWTEST_F(InteractionManagerTest, GetDragAction_004, TestSize.Level1)2296 HWTEST_F(InteractionManagerTest, GetDragAction_004, TestSize.Level1)
2297 {
2298     CALL_TEST_DEBUG;
2299     std::promise<bool> promiseFlag;
2300     std::future<bool> futureFlag = promiseFlag.get_future();
2301     auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
2302         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
2303             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
2304         promiseFlag.set_value(true);
2305     };
2306     std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
2307         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID_INJECT, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
2308     ASSERT_TRUE(dragData);
2309     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
2310         std::make_shared<UnitTestStartDragListener>(callback));
2311     ASSERT_EQ(ret, RET_OK);
2312     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::MOVE);
2313     ASSERT_EQ(ret, RET_OK);
2314     SimulateMovePointerEvent({ DRAG_SRC_X, DRAG_SRC_Y }, { DRAG_DST_X, DRAG_DST_Y },
2315         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, true);
2316     SimulateDownKeyEvent(MMI::KeyEvent::KEYCODE_CTRL_LEFT);
2317     SimulateDownKeyEvent(MMI::KeyEvent::KEYCODE_A);
2318     DragAction dragAction { DragAction::INVALID };
2319     ret = InteractionManager::GetInstance()->GetDragAction(dragAction);
2320     EXPECT_EQ(ret, RET_OK);
2321     EXPECT_EQ(dragAction, DragAction::COPY);
2322     SimulateUpKeyEvent(MMI::KeyEvent::KEYCODE_A);
2323     ret = InteractionManager::GetInstance()->GetDragAction(dragAction);
2324     EXPECT_EQ(ret, RET_OK);
2325     EXPECT_EQ(dragAction, DragAction::COPY);
2326     ClearUpKeyEvent();
2327     SimulateDownKeyEvent(MMI::KeyEvent::KEYCODE_B);
2328     ret = InteractionManager::GetInstance()->GetDragAction(dragAction);
2329     EXPECT_EQ(ret, RET_OK);
2330     EXPECT_EQ(dragAction, DragAction::COPY);
2331     SimulateUpKeyEvent(MMI::KeyEvent::KEYCODE_CTRL_LEFT);
2332     ret = InteractionManager::GetInstance()->GetDragAction(dragAction);
2333     EXPECT_EQ(ret, RET_OK);
2334     EXPECT_EQ(dragAction, DragAction::MOVE);
2335     ClearUpKeyEvent();
2336     DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
2337     InteractionManager::GetInstance()->StopDrag(dropResult);
2338     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
2339         std::future_status::timeout);
2340     ret = InteractionManager::GetInstance()->GetDragAction(dragAction);
2341     EXPECT_EQ(ret, RET_ERR);
2342 }
2343 
2344 /**
2345  * @tc.name: InteractionManagerTest_GetDragAction_005
2346  * @tc.desc: Get style notification with multiple press and release keyboard events of keys in dragging
2347  * @tc.type: FUNC
2348  * @tc.require:
2349  */
HWTEST_F(InteractionManagerTest, GetDragAction_005, TestSize.Level1)2350 HWTEST_F(InteractionManagerTest, GetDragAction_005, TestSize.Level1)
2351 {
2352     CALL_TEST_DEBUG;
2353     auto listener = std::make_shared<SubscriptListenerTest>("SubscriptListener");
2354     int32_t ret = InteractionManager::GetInstance()->AddSubscriptListener(listener);
2355     ASSERT_EQ(ret, RET_OK);
2356     std::promise<bool> promiseFlag;
2357     std::future<bool> futureFlag = promiseFlag.get_future();
2358     auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
2359         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
2360             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
2361         promiseFlag.set_value(true);
2362     };
2363     std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
2364         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID_INJECT, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
2365     ASSERT_TRUE(dragData);
2366     ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
2367         std::make_shared<UnitTestStartDragListener>(callback));
2368     ASSERT_EQ(ret, RET_OK);
2369     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::MOVE);
2370     ASSERT_EQ(ret, RET_OK);
2371     SimulateMovePointerEvent({ DRAG_SRC_X, DRAG_SRC_Y }, { DRAG_DST_X, DRAG_DST_Y },
2372         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, true);
2373     DragCursorStyle recvStyle = listener->GetDragStyle();
2374     EXPECT_EQ(recvStyle, DragCursorStyle::MOVE);
2375     SimulateDownKeyEvent(MMI::KeyEvent::KEYCODE_CTRL_LEFT);
2376     SimulateDownKeyEvent(MMI::KeyEvent::KEYCODE_B);
2377     recvStyle = listener->GetDragStyle();
2378     EXPECT_EQ(recvStyle, DragCursorStyle::COPY);
2379     SimulateUpKeyEvent(MMI::KeyEvent::KEYCODE_CTRL_LEFT);
2380     ClearUpKeyEvent();
2381     recvStyle = listener->GetDragStyle();
2382     EXPECT_EQ(recvStyle, DragCursorStyle::MOVE);
2383     SimulateDownKeyEvent(MMI::KeyEvent::KEYCODE_CTRL_RIGHT);
2384     recvStyle = listener->GetDragStyle();
2385     EXPECT_EQ(recvStyle, DragCursorStyle::COPY);
2386     SimulateUpKeyEvent(MMI::KeyEvent::KEYCODE_B);
2387     ClearUpKeyEvent();
2388     recvStyle = listener->GetDragStyle();
2389     EXPECT_EQ(recvStyle, DragCursorStyle::COPY);
2390     SimulateUpKeyEvent(MMI::KeyEvent::KEYCODE_CTRL_RIGHT);
2391     ClearUpKeyEvent();
2392     recvStyle = listener->GetDragStyle();
2393     EXPECT_EQ(recvStyle, DragCursorStyle::MOVE);
2394     DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
2395     InteractionManager::GetInstance()->StopDrag(dropResult);
2396     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
2397         std::future_status::timeout);
2398     ret = InteractionManager::GetInstance()->RemoveSubscriptListener(listener);
2399     ASSERT_EQ(ret, RET_OK);
2400 }
2401 
2402 /**
2403  * @tc.name: InteractionManagerTest_CheckDragBehavior_001
2404  * @tc.desc: Check drag behavior
2405  * @tc.type: FUNC
2406  * @tc.require:
2407  */
HWTEST_F(InteractionManagerTest, CheckDragBehavior_001, TestSize.Level1)2408 HWTEST_F(InteractionManagerTest, CheckDragBehavior_001, TestSize.Level1)
2409 {
2410     CALL_TEST_DEBUG;
2411     std::promise<bool> promiseFlag;
2412     std::future<bool> futureFlag = promiseFlag.get_future();
2413     auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
2414         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, dragBehavior:%{public}d",
2415             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.dragBehavior);
2416         ASSERT_EQ(notifyMessage.dragBehavior, DragBehavior::COPY);
2417         promiseFlag.set_value(true);
2418     };
2419     std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
2420         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
2421     ASSERT_TRUE(dragData);
2422     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
2423         std::make_shared<UnitTestStartDragListener>(callback));
2424     ASSERT_EQ(ret, RET_OK);
2425     DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION,
2426         TARGET_MAIN_WINDOW, DragBehavior::COPY };
2427     InteractionManager::GetInstance()->StopDrag(dropResult);
2428     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
2429         std::future_status::timeout);
2430 }
2431 
2432 /**
2433  * @tc.name: InteractionManagerTest_CheckDragBehavior_002
2434  * @tc.desc: Check drag behavior
2435  * @tc.type: FUNC
2436  * @tc.require:
2437  */
HWTEST_F(InteractionManagerTest, CheckDragBehavior_002, TestSize.Level1)2438 HWTEST_F(InteractionManagerTest, CheckDragBehavior_002, TestSize.Level1)
2439 {
2440     CALL_TEST_DEBUG;
2441     std::promise<bool> promiseFlag;
2442     std::future<bool> futureFlag = promiseFlag.get_future();
2443     auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
2444         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, dragBehavior:%{public}d",
2445             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.dragBehavior);
2446         ASSERT_EQ(notifyMessage.dragBehavior, DragBehavior::MOVE);
2447         promiseFlag.set_value(true);
2448     };
2449     std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
2450         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
2451     ASSERT_TRUE(dragData);
2452     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
2453         std::make_shared<UnitTestStartDragListener>(callback));
2454     ASSERT_EQ(ret, RET_OK);
2455     DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION,
2456         TARGET_MAIN_WINDOW, DragBehavior::MOVE };
2457     InteractionManager::GetInstance()->StopDrag(dropResult);
2458     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
2459         std::future_status::timeout);
2460 }
2461 
2462 /**
2463  * @tc.name: InteractionManagerTest_CheckDragBehavior_003
2464  * @tc.desc: Check drag behavior
2465  * @tc.type: FUNC
2466  * @tc.require:
2467  */
HWTEST_F(InteractionManagerTest, CheckDragBehavior_003, TestSize.Level1)2468 HWTEST_F(InteractionManagerTest, CheckDragBehavior_003, TestSize.Level1)
2469 {
2470     CALL_TEST_DEBUG;
2471     std::promise<bool> promiseFlag;
2472     std::future<bool> futureFlag = promiseFlag.get_future();
2473     auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
2474         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, dragBehavior:%{public}d",
2475             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.dragBehavior);
2476         ASSERT_EQ(notifyMessage.dragBehavior, DragBehavior::COPY);
2477         promiseFlag.set_value(true);
2478     };
2479     std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
2480         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
2481     ASSERT_TRUE(dragData);
2482     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
2483         std::make_shared<UnitTestStartDragListener>(callback));
2484     ASSERT_EQ(ret, RET_OK);
2485     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::COPY);
2486     ASSERT_EQ(ret, RET_OK);
2487     DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, TARGET_MAIN_WINDOW };
2488     InteractionManager::GetInstance()->StopDrag(dropResult);
2489     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
2490         std::future_status::timeout);
2491 }
2492 
2493 /**
2494  * @tc.name: InteractionManagerTest_CheckDragBehavior_004
2495  * @tc.desc: Check drag behavior
2496  * @tc.type: FUNC
2497  * @tc.require:
2498  */
HWTEST_F(InteractionManagerTest, CheckDragBehavior_004, TestSize.Level1)2499 HWTEST_F(InteractionManagerTest, CheckDragBehavior_004, TestSize.Level1)
2500 {
2501     CALL_TEST_DEBUG;
2502     std::promise<bool> promiseFlag;
2503     std::future<bool> futureFlag = promiseFlag.get_future();
2504     auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
2505         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, dragBehavior:%{public}d",
2506             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.dragBehavior);
2507         ASSERT_EQ(notifyMessage.dragBehavior, DragBehavior::MOVE);
2508         promiseFlag.set_value(true);
2509     };
2510     std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
2511         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
2512     ASSERT_TRUE(dragData);
2513     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
2514         std::make_shared<UnitTestStartDragListener>(callback));
2515     ASSERT_EQ(ret, RET_OK);
2516     DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, TARGET_MAIN_WINDOW };
2517     InteractionManager::GetInstance()->StopDrag(dropResult);
2518     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
2519         std::future_status::timeout);
2520 }
2521 
2522 /**
2523  * @tc.name: InteractionManagerTest_CheckDragBehavior_005
2524  * @tc.desc: Check drag behavior
2525  * @tc.type: FUNC
2526  * @tc.require:
2527  */
HWTEST_F(InteractionManagerTest, CheckDragBehavior_005, TestSize.Level1)2528 HWTEST_F(InteractionManagerTest, CheckDragBehavior_005, TestSize.Level1)
2529 {
2530     CALL_TEST_DEBUG;
2531     std::promise<bool> promiseFlag;
2532     std::future<bool> futureFlag = promiseFlag.get_future();
2533     auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
2534         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, dragBehavior:%{public}d",
2535             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.dragBehavior);
2536         ASSERT_EQ(notifyMessage.dragBehavior, DragBehavior::COPY);
2537         promiseFlag.set_value(true);
2538     };
2539     std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
2540         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
2541     ASSERT_TRUE(dragData);
2542     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
2543         std::make_shared<UnitTestStartDragListener>(callback));
2544     ASSERT_EQ(ret, RET_OK);
2545     int32_t targetMainWindow = 1;
2546     DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, targetMainWindow };
2547     InteractionManager::GetInstance()->StopDrag(dropResult);
2548     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
2549         std::future_status::timeout);
2550 }
2551 
2552 /**
2553  * @tc.name: InteractionManagerTest_CheckDragBehavior_006
2554  * @tc.desc: Check drag behavior
2555  * @tc.type: FUNC
2556  * @tc.require:
2557  */
HWTEST_F(InteractionManagerTest, CheckDragBehavior_006, TestSize.Level1)2558 HWTEST_F(InteractionManagerTest, CheckDragBehavior_006, TestSize.Level1)
2559 {
2560     CALL_TEST_DEBUG;
2561     std::promise<bool> promiseFlag;
2562     std::future<bool> futureFlag = promiseFlag.get_future();
2563     auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
2564         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, dragBehavior:%{public}d",
2565             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.dragBehavior);
2566         ASSERT_EQ(notifyMessage.dragBehavior, DragBehavior::UNKNOWN);
2567         promiseFlag.set_value(true);
2568     };
2569     std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
2570         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, TOUCH_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
2571     ASSERT_TRUE(dragData);
2572     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
2573         std::make_shared<UnitTestStartDragListener>(callback));
2574     ASSERT_EQ(ret, RET_OK);
2575     DragDropResult dropResult { DragResult::DRAG_FAIL, HAS_CUSTOM_ANIMATION, TARGET_MAIN_WINDOW };
2576     InteractionManager::GetInstance()->StopDrag(dropResult);
2577     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
2578         std::future_status::timeout);
2579 }
2580 
2581 /**
2582  * @tc.name: InteractionManagerTest_StartDrag_Shadow
2583  * @tc.desc: Check drag shadow
2584  * @tc.type: FUNC
2585  * @tc.require:
2586  */
HWTEST_F(InteractionManagerTest, InteractionManagerTest_StartDrag_Shadow, TestSize.Level1)2587 HWTEST_F(InteractionManagerTest, InteractionManagerTest_StartDrag_Shadow, TestSize.Level1)
2588 {
2589     CALL_TEST_DEBUG;
2590     std::promise<bool> promiseFlag;
2591     std::future<bool> futureFlag = promiseFlag.get_future();
2592     auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
2593         FI_HILOGD("Param displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
2594             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
2595         promiseFlag.set_value(true);
2596     };
2597     SimulateDownPointerEvent(
2598         { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID);
2599     std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
2600         MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
2601     ASSERT_TRUE(dragData);
2602     dragData->filterInfo = "{ \"dip_scale\": 3.5, \"drag_shadow_offsetX\": 30, \"drag_shadow_offsetY\": 30, "
2603         "\"drag_shadow_argb\": 4294967295, \"drag_shadow_path\": \"M 10 10 H 80 V 80 H 10 L 10 10\", "
2604 		"\"shadow_color_strategy\": 0, \"shadow_is_hardwareacceleration\": true, \"shadow_elevation\": 120, "
2605 		"\"drag_type\": \"text\", \"shadow_enable\": true }";
2606     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
2607         std::make_shared<UnitTestStartDragListener>(callback));
2608     ASSERT_EQ(ret, RET_OK);
2609     ret = InteractionManager::GetInstance()->SetDragWindowVisible(true);
2610     EXPECT_EQ(ret, RET_OK);
2611     SimulateMovePointerEvent({ DRAG_SRC_X, DRAG_SRC_Y }, { DRAG_DST_X, DRAG_DST_Y },
2612         MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, true);
2613     DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
2614     InteractionManager::GetInstance()->StopDrag(dropResult);
2615     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
2616         std::future_status::timeout);
2617 }
2618 
2619 /**
2620  * @tc.name: InteractionManagerTest_StartDrag_ShadowAlpha
2621  * @tc.desc: Check drag shadow alpha
2622  * @tc.type: FUNC
2623  * @tc.require:
2624  */
HWTEST_F(InteractionManagerTest, InteractionManagerTest_StartDrag_ShadowAlpha, TestSize.Level1)2625 HWTEST_F(InteractionManagerTest, InteractionManagerTest_StartDrag_ShadowAlpha, TestSize.Level1)
2626 {
2627     CALL_TEST_DEBUG;
2628     std::promise<bool> promiseFlag;
2629     std::future<bool> futureFlag = promiseFlag.get_future();
2630     auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
2631         FI_HILOGD("Param displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
2632             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
2633         promiseFlag.set_value(true);
2634     };
2635     SimulateDownPointerEvent(
2636         { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID);
2637     std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
2638         MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
2639     ASSERT_TRUE(dragData);
2640     dragData->filterInfo = "{ \"dip_scale\": 3.5, \"drag_shadow_offsetX\": 30, \"drag_shadow_offsetY\": 30, "
2641         "\"drag_shadow_argb\": 872415231, \"drag_shadow_path\": \"M 10 10 H 80 V 80 H 10 L 10 10\", "
2642 		"\"shadow_color_strategy\": 0, \"shadow_is_hardwareacceleration\": true, \"shadow_elevation\": 120, "
2643 		"\"drag_type\": \"text\", \"shadow_enable\": true }";
2644     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
2645         std::make_shared<UnitTestStartDragListener>(callback));
2646     ASSERT_EQ(ret, RET_OK);
2647     ret = InteractionManager::GetInstance()->SetDragWindowVisible(true);
2648     EXPECT_EQ(ret, RET_OK);
2649     SimulateMovePointerEvent({ DRAG_SRC_X, DRAG_SRC_Y }, { DRAG_DST_X, DRAG_DST_Y },
2650         MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, true);
2651     DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
2652     InteractionManager::GetInstance()->StopDrag(dropResult);
2653     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
2654         std::future_status::timeout);
2655 }
2656 
2657 /**
2658  * @tc.name: InteractionManagerTest_StartDrag_ShadowColor
2659  * @tc.desc: Check drag shadow color
2660  * @tc.type: FUNC
2661  * @tc.require:
2662  */
HWTEST_F(InteractionManagerTest, InteractionManagerTest_StartDrag_ShadowColor, TestSize.Level1)2663 HWTEST_F(InteractionManagerTest, InteractionManagerTest_StartDrag_ShadowColor, TestSize.Level1)
2664 {
2665     CALL_TEST_DEBUG;
2666     std::promise<bool> promiseFlag;
2667     std::future<bool> futureFlag = promiseFlag.get_future();
2668     auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
2669         FI_HILOGD("Param displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
2670             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
2671         promiseFlag.set_value(true);
2672     };
2673     SimulateDownPointerEvent(
2674         { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID);
2675     std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
2676         MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
2677     ASSERT_TRUE(dragData);
2678     dragData->filterInfo = "{ \"dip_scale\": 3.5, \"drag_shadow_offsetX\": 30, \"drag_shadow_offsetY\": 30, "
2679         "\"drag_shadow_argb\": 872415231, \"drag_shadow_path\": \"M 10 10 H 80 V 80 H 10 L 10 10\", "
2680 		"\"shadow_color_strategy\": 0, \"shadow_is_hardwareacceleration\": true, \"shadow_elevation\": 120, "
2681 		"\"drag_type\": \"text\", \"shadow_enable\": true }";
2682     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
2683         std::make_shared<UnitTestStartDragListener>(callback));
2684     ASSERT_EQ(ret, RET_OK);
2685     ret = InteractionManager::GetInstance()->SetDragWindowVisible(true);
2686     EXPECT_EQ(ret, RET_OK);
2687     SimulateMovePointerEvent({ DRAG_SRC_X, DRAG_SRC_Y }, { DRAG_DST_X, DRAG_DST_Y },
2688         MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, true);
2689     DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
2690     InteractionManager::GetInstance()->StopDrag(dropResult);
2691     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
2692         std::future_status::timeout);
2693 }
2694 
2695 /**
2696  * @tc.name: InteractionManagerTest_StartDrag_ShadowOffset
2697  * @tc.desc: Check drag shadow offset
2698  * @tc.type: FUNC
2699  * @tc.require:
2700  */
HWTEST_F(InteractionManagerTest, InteractionManagerTest_StartDrag_ShadowOffset, TestSize.Level1)2701 HWTEST_F(InteractionManagerTest, InteractionManagerTest_StartDrag_ShadowOffset, TestSize.Level1)
2702 {
2703     CALL_TEST_DEBUG;
2704     std::promise<bool> promiseFlag;
2705     std::future<bool> futureFlag = promiseFlag.get_future();
2706     auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
2707         FI_HILOGD("Param displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
2708             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
2709         promiseFlag.set_value(true);
2710     };
2711     SimulateDownPointerEvent(
2712         { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID);
2713     std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
2714         MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
2715     ASSERT_TRUE(dragData);
2716     dragData->filterInfo = "{ \"dip_scale\": 3.5, \"drag_shadow_offsetX\": 50, \"drag_shadow_offsetY\": 50, "
2717         "\"drag_shadow_argb\": 872415231, \"drag_shadow_path\": \"M 10 10 H 80 V 80 H 10 L 10 10\", "
2718 		"\"shadow_color_strategy\": 0, \"shadow_is_hardwareacceleration\": true, \"shadow_elevation\": 120, "
2719 		"\"drag_type\": \"text\", \"shadow_enable\": true }";
2720     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
2721         std::make_shared<UnitTestStartDragListener>(callback));
2722     ASSERT_EQ(ret, RET_OK);
2723     ret = InteractionManager::GetInstance()->SetDragWindowVisible(true);
2724     EXPECT_EQ(ret, RET_OK);
2725     SimulateMovePointerEvent({ DRAG_SRC_X, DRAG_SRC_Y }, { DRAG_DST_X, DRAG_DST_Y },
2726         MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, true);
2727     DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
2728     InteractionManager::GetInstance()->StopDrag(dropResult);
2729     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
2730         std::future_status::timeout);
2731 }
2732 
2733 /**
2734  * @tc.name: InteractionManagerTest_StartDrag_ShadowCornerRadius
2735  * @tc.desc: Check drag shadow corner radius
2736  * @tc.type: FUNC
2737  * @tc.require:
2738  */
HWTEST_F(InteractionManagerTest, InteractionManagerTest_StartDrag_ShadowCornerRadius, TestSize.Level1)2739 HWTEST_F(InteractionManagerTest, InteractionManagerTest_StartDrag_ShadowCornerRadius, TestSize.Level1)
2740 {
2741     CALL_TEST_DEBUG;
2742     std::promise<bool> promiseFlag;
2743     std::future<bool> futureFlag = promiseFlag.get_future();
2744     auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
2745         FI_HILOGD("Param displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
2746             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
2747         promiseFlag.set_value(true);
2748     };
2749     SimulateDownPointerEvent(
2750         { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID);
2751     std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
2752         MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
2753     ASSERT_TRUE(dragData);
2754     dragData->filterInfo = "{ \"dip_scale\": 3.5, \"drag_shadow_offsetX\": 30, \"drag_shadow_offsetY\": 30, "
2755         "\"drag_shadow_argb\": 872415231, \"drag_shadow_path\": \"M 10 10 H 80 V 80 H 10 L 10 10\", "
2756 		"\"shadow_color_strategy\": 0, \"shadow_is_hardwareacceleration\": false, \"shadow_corner\": 120, "
2757 		"\"drag_type\": \"text\", \"shadow_enable\": true }";
2758     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
2759         std::make_shared<UnitTestStartDragListener>(callback));
2760     ASSERT_EQ(ret, RET_OK);
2761     ret = InteractionManager::GetInstance()->SetDragWindowVisible(true);
2762     EXPECT_EQ(ret, RET_OK);
2763     SimulateMovePointerEvent({ DRAG_SRC_X, DRAG_SRC_Y }, { DRAG_DST_X, DRAG_DST_Y },
2764         MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, true);
2765     DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
2766     InteractionManager::GetInstance()->StopDrag(dropResult);
2767     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
2768         std::future_status::timeout);
2769 }
2770 
2771 /**
2772  * @tc.name: InteractionManagerTest_StartDrag_ShadowPath001
2773  * @tc.desc: Check drag shadow path
2774  * @tc.type: FUNC
2775  * @tc.require:
2776  */
HWTEST_F(InteractionManagerTest, InteractionManagerTest_StartDrag_ShadowPath001, TestSize.Level1)2777 HWTEST_F(InteractionManagerTest, InteractionManagerTest_StartDrag_ShadowPath001, TestSize.Level1)
2778 {
2779     CALL_TEST_DEBUG;
2780     std::promise<bool> promiseFlag;
2781     std::future<bool> futureFlag = promiseFlag.get_future();
2782     auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
2783         FI_HILOGD("Param displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
2784             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
2785         promiseFlag.set_value(true);
2786     };
2787     SimulateDownPointerEvent(
2788         { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID);
2789     std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
2790         MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
2791     ASSERT_TRUE(dragData);
2792     dragData->filterInfo = "{ \"dip_scale\": 3.5, \"drag_shadow_offsetX\": 50, \"drag_shadow_offsetY\": 50, "
2793         "\"drag_shadow_argb\": 872415231, \"drag_shadow_path\": \"M 10 10 H 90 V 90 H 10 L 10 10\", "
2794 		"\"shadow_color_strategy\": 0, \"shadow_is_hardwareacceleration\": true, \"shadow_elevation\": 120, "
2795 		"\"drag_type\": \"text\", \"shadow_enable\": true }";
2796     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
2797         std::make_shared<UnitTestStartDragListener>(callback));
2798     ASSERT_EQ(ret, RET_OK);
2799     ret = InteractionManager::GetInstance()->SetDragWindowVisible(true);
2800     EXPECT_EQ(ret, RET_OK);
2801     SimulateMovePointerEvent({ DRAG_SRC_X, DRAG_SRC_Y }, { DRAG_DST_X, DRAG_DST_Y },
2802         MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, true);
2803     DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
2804     InteractionManager::GetInstance()->StopDrag(dropResult);
2805     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
2806         std::future_status::timeout);
2807 }
2808 
2809 /**
2810  * @tc.name: InteractionManagerTest_StartDrag_ShadowPath002
2811  * @tc.desc: Check drag shadow path
2812  * @tc.type: FUNC
2813  * @tc.require:
2814  */
HWTEST_F(InteractionManagerTest, InteractionManagerTest_StartDrag_ShadowPath002, TestSize.Level1)2815 HWTEST_F(InteractionManagerTest, InteractionManagerTest_StartDrag_ShadowPath002, TestSize.Level1)
2816 {
2817     CALL_TEST_DEBUG;
2818     std::promise<bool> promiseFlag;
2819     std::future<bool> futureFlag = promiseFlag.get_future();
2820     auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
2821         FI_HILOGD("Param displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
2822             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
2823         promiseFlag.set_value(true);
2824     };
2825     SimulateDownPointerEvent(
2826         { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID);
2827     std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
2828         MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
2829     ASSERT_TRUE(dragData);
2830     dragData->filterInfo = "{ \"dip_scale\": 3.5, \"drag_shadow_offsetX\": 50, \"drag_shadow_offsetY\": 50, "
2831         "\"drag_shadow_argb\": 872415231, "
2832 		"\"shadow_color_strategy\": 0, \"shadow_is_hardwareacceleration\": true, \"shadow_elevation\": 120, "
2833 		"\"drag_type\": \"text\", \"shadow_enable\": true }";
2834     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
2835         std::make_shared<UnitTestStartDragListener>(callback));
2836     ASSERT_EQ(ret, RET_OK);
2837     ret = InteractionManager::GetInstance()->SetDragWindowVisible(true);
2838     EXPECT_EQ(ret, RET_OK);
2839     SimulateMovePointerEvent({ DRAG_SRC_X, DRAG_SRC_Y }, { DRAG_DST_X, DRAG_DST_Y },
2840         MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, true);
2841     DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
2842     InteractionManager::GetInstance()->StopDrag(dropResult);
2843     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
2844         std::future_status::timeout);
2845 }
2846 
2847 /**
2848  * @tc.name: InteractionManagerTest_StartDrag_NonTextShadow
2849  * @tc.desc: Check non-text drag shadow
2850  * @tc.type: FUNC
2851  * @tc.require:
2852  */
HWTEST_F(InteractionManagerTest, InteractionManagerTest_StartDrag_NonTextShadow, TestSize.Level1)2853 HWTEST_F(InteractionManagerTest, InteractionManagerTest_StartDrag_NonTextShadow, TestSize.Level1)
2854 {
2855     CALL_TEST_DEBUG;
2856     std::promise<bool> promiseFlag;
2857     std::future<bool> futureFlag = promiseFlag.get_future();
2858     auto callback = [&promiseFlag](const DragNotifyMsg& notifyMessage) {
2859         FI_HILOGD("Param displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
2860             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
2861         promiseFlag.set_value(true);
2862     };
2863     SimulateDownPointerEvent(
2864         { DRAG_SRC_X, DRAG_SRC_Y }, MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID);
2865     std::optional<DragData> dragData = CreateDragData({ TEST_PIXEL_MAP_WIDTH, TEST_PIXEL_MAP_HEIGHT },
2866         MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, DISPLAY_ID, { DRAG_SRC_X, DRAG_SRC_Y });
2867     ASSERT_TRUE(dragData);
2868     dragData->filterInfo = "{ \"dip_scale\": 3.5, \"drag_shadow_offsetX\": 50, \"drag_shadow_offsetY\": 50, "
2869         "\"drag_shadow_argb\": 872415231, "
2870 		"\"shadow_color_strategy\": 0, \"shadow_is_hardwareacceleration\": true, \"shadow_elevation\": 120, "
2871 		"\"drag_type\": \"non-text\", \"shadow_enable\": true }";
2872     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
2873         std::make_shared<UnitTestStartDragListener>(callback));
2874     ASSERT_EQ(ret, RET_OK);
2875     ret = InteractionManager::GetInstance()->SetDragWindowVisible(true);
2876     EXPECT_EQ(ret, RET_OK);
2877     SimulateMovePointerEvent({ DRAG_SRC_X, DRAG_SRC_Y }, { DRAG_DST_X, DRAG_DST_Y },
2878         MMI::PointerEvent::SOURCE_TYPE_MOUSE, MOUSE_POINTER_ID, true);
2879     DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
2880     InteractionManager::GetInstance()->StopDrag(dropResult);
2881     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
2882         std::future_status::timeout);
2883     ret = InteractionManager::GetInstance()->EraseMouseIcon();
2884     EXPECT_NE(ret, RET_OK);
2885     ret = InteractionManager::GetInstance()->SetMouseDragMonitorState(0);
2886     EXPECT_EQ(ret, RET_OK);
2887 }
2888 } // namespace DeviceStatus
2889 } // namespace Msdp
2890 } // namespace OHOS
2891